SpatialFear.SFPlayer

//=============================================================================
// Spatial Fear
// Name: SFPlayer
// Description: SpatialFear implementation of general player behaviour.
//				Since the MOD is strongly based on these changes, this is
//				our workhorse class. Modify it wisely!
//
// Author: Markus Nuebel
//=============================================================================

#exec AUDIO IMPORT FILE="Sounds\male\climb1.WAV" NAME="MClimb1" GROUP="Male"
#exec AUDIO IMPORT FILE="Sounds\female\climb1.WAV" NAME="FClimb1" GROUP="Female"

class SFPlayer extends TournamentPlayer;

////////////////////
// enumerations
////////////////////
enum EPlayerState
{
	STATE_UNDEF,
	STATE_Crouch,
	STATE_Creep,
	STATE_Climb,
	STATE_Swim,
	STATE_Normal,
};

enum EScreenEffect
{
	EFFECT_NONE,
	EFFECT_LR_WIPE
};

// Public class members
var (Penalty) float JumpAccuracyPenalty;
var (Penalty) float RunAccuracyPenalty;
var (Penalty) float StrafeAccuracyPenalty;
var (Penalty) float m_fPenaltyUpgrade;
var (Movement) float SafeFall_Damage;
var (Movement) float SafeFall_Kill;
var (Collision) float CollisionHeightCrouch;
var (Collision) float CollisionHeightCreep;
var (Collision) float Correction;
var (SpatialFear) int nShowVersionTime;
var (SpatialFear) float NormalSpeed;
var (SpatialFear) float CrouchSpeed;
var (SpatialFear) float CreepSpeed;

var (Sounds) sound ClimbStep;

// Private class members
var bool  m_bCannotDrown;
var float m_fGroundSpeedOrg;
var float m_fAirSpeedOrg;
var float m_fWaterSpeedOrg;
var float m_fAccelRate;
var float m_fCurrentSpeedModification;
var float m_fFrobTime;
var float m_fInitialPrePivotZ;
var int	m_nSafeFallDamage;
var int m_nSafeFallKill;
var SFMedStationMover	m_actNearestMedStation;

var EScreenEffect m_screenEffect;
var int m_nXWipePos;

var string	strSFVersion;
var bool	bShowVersionInfo;
var bool	bJumpPenaltyAdded;
var bool	bRunPenaltyAdded;
var bool	bStrafePenaltyAdded;

var bool	m_bIsJumping;
var bool	m_bIsRunning;
var bool	m_bIsStrafing;
var bool	m_bIsCreeping;
var byte	m_bStandState;

var byte		m_bUseKey;
var input byte	m_bCreep;
var bool		m_bManualInput;
var byte		m_bSavedDuck;
var byte		m_bSavedCreep;

var SFWeapon	oModifiedWeapon;
var float   fPenaltyModifier;
var int		nPenaltyCount;
var EPlayerState	PlayerState;
var EPlayerState	StartingPlayerState;	// Player state, before collision height corrections are taking place

var float   fDiffStandCrouch;
var float   fDiffCrouchCreep;
var float   fDiffStandCreep;

var Weapon	m_oCreepPendingWeapon;
var bool	m_bInventoryOpen; // Private: Inventory window open/closed:
var bool 	m_bWeaponSelectOpen; // Private: Weapon Upgrade select window open/closed
var bool	m_bDreamMode; // Private: Indicates that player is in dreammode. E.g. no footsteps should be played. Default: false
var float	m_fFootstepVolume; // Private: Footstep volume. Default: 2.2
// Window stuff
var UWindowMessageBox winConfirmLoad;

// Upgrade modules
var travel  bool				m_bWeaponDescUpgrade;
var travel  bool				m_bVisorUnitUpgrade;
var travel	SFDamageProtection	m_oSmartVest;

var travel SFFlashlight m_oFlashlight;

// STATS
var bool bStatPlayer;
var bool bStatWeapon;
var bool bStatInventory;

// Goaltable;
var travel SFGoaltable					m_oGoals;

const  NO_ACCURACY=-1.0;

var input byte bDuck;
var transient UWindowRootWindow  Root;

// Smell system
var float	m_fLastPheromoneSpawn;
var bool	m_bViewScent;

// Save games
var int m_nLastSaveSlot;
var bool m_bLoadDialogOpened;

// testing
var float fSoundPitch;

// AI testing
var Pawn	pawnCreatureMonitor;

// List of seen communications
var SFCommDetail	m_listCommunications;
var SFCommunication	m_oScoutBotComm;
// ScoutBot stuff
var Decoration ScoutBot;

// Null Weapon
var Weapon m_oNullWeaponRestore;

////////////////////
// Console commands
////////////////////

exec function SFToggleFlashlight()
{
	local Inventory	oItem;

	oItem	= Inventory;
	while(None != oItem)
	{
		if(oItem.IsA('SFFlashlight'))
		{
			oItem.Activate();
			return;
		}
		oItem	= oItem.Inventory;
	}

	ClientMessage("You do not own the flashlight.");

}
exec function ViewClass( class<actor> aClass, optional bool bQuiet )
{
}

exec function SFViewScents(int n)
{
	if(0 == n)
		m_bViewScent = false;
	else
		m_bViewScent = true;
}

exec function SFViewCreature(name nameClass)
{
	local Pawn	P;

	pawnCreatureMonitor = None;

	for ( P=Level.PawnList; P!=None; P=P.NextPawn )
		if ( P.IsA(nameClass) )
		{
			pawnCreatureMonitor = P;
		}

}
// Modifies the players health
exec function SFHealth(int nHealth)
{
	Health = nHealth;
}

// upgrades the player accuracy
function increasePenalty(float fUpgrade)
{
	// First reset all penalties
	resetPenalties();

	// Do the upgrade
	m_fPenaltyUpgrade -= fUpgrade;

	if(0.0 > m_fPenaltyUpgrade)
		m_fPenaltyUpgrade = 0.0f;

	// Calculate new penalties
	AdjustAccuracy();
}

// Enables the different HUD modules
exec function SFEnableHUD(name Type)
{
	if(('VISOR' == Type) || ('ALL' == Type))
		m_bVisorUnitUpgrade=true;

	if(('WEAPON' == Type) || ('ALL' == Type))
		m_bWeaponDescUpgrade=true;
}

// Allows to modify the weapon penalties
exec function SFAccuracy(name Type, float fAccuracy)
{
	// Set the different penalties
	if('JUMP' == Type)
		JumpAccuracyPenalty		= fAccuracy;
	if('RUN' == Type)
		RunAccuracyPenalty		= fAccuracy;
	if('STRAFE' == Type)
		StrafeAccuracyPenalty	= fAccuracy;
}

// Base class override, to prevent weapon switching in creep state
exec function PrevWeapon()
{
	local int prevGroup;
	local Inventory inv;
	local Weapon realWeapon, w, Prev;
	local bool bFoundWeapon;

	// SF state check
	if((PlayerState == STATE_Creep) || (m_bDreamMode))
		return;

	if( bShowMenu || Level.Pauser!="" )
		return;

	// No switch while picking up something
	if(None != PendingWeapon)
		if(PendingWeapon.IsA('SFNullGun') && (None != CarriedDecoration))
			return;

	// No switch while holding something
	if(None != Weapon)
		if(Weapon.IsA('SFNullGun') && (None != CarriedDecoration))
			return;

	if ( Weapon == None )
	{
		SwitchToBestWeapon();
		return;
	}
	prevGroup = 0;
	realWeapon = Weapon;
	if ( PendingWeapon != None )
		Weapon = PendingWeapon;
	PendingWeapon = None;

	for (inv=Inventory; inv!=None; inv=inv.Inventory)
	{
		w = Weapon(inv);
		if ( w != None )
		{
			if ( w.InventoryGroup == Weapon.InventoryGroup )
			{
				if ( w == Weapon )
				{
					bFoundWeapon = true;
					if ( Prev != None )
					{
						PendingWeapon = Prev;
						break;
					}
				}
				else if ( !bFoundWeapon && ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot()))) )
					Prev = W;
			}
			else if ( (w.InventoryGroup < Weapon.InventoryGroup)
					&& ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot())))
					&& (w.InventoryGroup >= prevGroup) )
			{
				prevGroup = w.InventoryGroup;
				PendingWeapon = w;
			}
		}
	}
	bFoundWeapon = false;
	prevGroup = Weapon.InventoryGroup;
	if ( PendingWeapon == None )
		for (inv=Inventory; inv!=None; inv=inv.Inventory)
		{
			w = Weapon(inv);
			if ( w != None )
			{
				if ( w.InventoryGroup == Weapon.InventoryGroup )
				{
					if ( w == Weapon )
						bFoundWeapon = true;
					else if ( bFoundWeapon && (PendingWeapon == None) && ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot()))) )
						PendingWeapon = W;
				}
				else if ( (w.InventoryGroup > PrevGroup)
						&& ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot()))) )
				{
					prevGroup = w.InventoryGroup;
					PendingWeapon = w;
				}
			}
		}

	Weapon = realWeapon;
	if ( PendingWeapon == None )
		return;

	Weapon.PutDown();
}

// Base class override, to prevent weapon switching in creep state
exec function NextWeapon()
{
	local int nextGroup;
	local Inventory inv;
	local Weapon realWeapon, w, Prev;
	local bool bFoundWeapon;

	// SFState check here
	if((PlayerState == STATE_Creep) || (m_bDreamMode))
		return;
	if( bShowMenu || Level.Pauser!="" )
		return;

	// No switch while picking up something
	if(None != PendingWeapon)
		if(PendingWeapon.IsA('SFNullGun') && (None != CarriedDecoration))
			return;
	// No switch while holding something
	if(None != Weapon)
		if(Weapon.IsA('SFNullGun') && (None != CarriedDecoration))
			return;

	if ( Weapon == None )
	{
		SwitchToBestWeapon();
		return;
	}
	nextGroup = 100;
	realWeapon = Weapon;
	if ( PendingWeapon != None )
		Weapon = PendingWeapon;
	PendingWeapon = None;

	for (inv=Inventory; inv!=None; inv=inv.Inventory)
	{
		w = Weapon(inv);
		if ( w != None )
		{
			if ( w.InventoryGroup == Weapon.InventoryGroup )
			{
				if ( w == Weapon )
					bFoundWeapon = true;
				else if ( bFoundWeapon && ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot()))) )
				{
					PendingWeapon = W;
					break;
				}
			}
			else if ( (w.InventoryGroup > Weapon.InventoryGroup)
					&& ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot())))
					&& (w.InventoryGroup < nextGroup) )
			{
				nextGroup = w.InventoryGroup;
				PendingWeapon = w;
			}
		}
	}

	bFoundWeapon = false;
	nextGroup = Weapon.InventoryGroup;
	if ( PendingWeapon == None )
		for (inv=Inventory; inv!=None; inv=inv.Inventory)
		{
			w = Weapon(Inv);
			if ( w != None )
			{
				if ( w.InventoryGroup == Weapon.InventoryGroup )
				{
					if ( w == Weapon )
					{
						bFoundWeapon = true;
						if ( Prev != None )
							PendingWeapon = Prev;
					}
					else if ( !bFoundWeapon && (PendingWeapon == None) && ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot()))) )
						Prev = W;
				}
				else if ( (w.InventoryGroup < nextGroup)
					&& ((w.AmmoType == None) || (w.AmmoType.AmmoAmount>(SFWeapon(w).getAmmoPerShot()))) )
				{
					nextGroup = w.InventoryGroup;
					PendingWeapon = w;
				}
			}
		}

	Weapon = realWeapon;
	if ( PendingWeapon == None )
		return;

	Weapon.PutDown();
}

// Adjusts the UseKey range
exec function SFUseKeyRange(int nValue)
{
	SFGameInfo(Level.Game).nUseKeyRange = nValue;
}

// Adjusts the player crouching collision height
exec function SFCrouchHeight(float fValue)
{
	CollisionHeightCrouch = fValue;
}

// Adjusts the player creep collision height
exec function SFCreepHeight(float fValue)
{
	CollisionHeightCreep = fValue;
}

// Adjust the footstep volume
exec function SFFootstepVolume(float fValue)
{
	if((0.0 > fValue) || (10.0 < fValue))
		sfClientError("Invalid range >0.0 - 10.0<");

	m_fFootstepVolume = fValue;
}

// Adjusts the player speed in relation to the original setting
exec function SFPlayerSpeed(float fPercentage, optional bool bTrackModification)
{
	if((0.0 > fPercentage) || (10.0 < fPercentage))
		sfClientError("Invalid range >0.0 - 10.0<");

	if(!bTrackModification)
	{
		// No modification of current speed modification value
		// Everything is relative to the original settings
		GroundSpeed = fPercentage * m_fCurrentSpeedModification * m_fGroundSpeedOrg;
		AirSpeed	= fPercentage * m_fCurrentSpeedModification * m_fAirSpeedOrg;
		WaterSpeed	= fPercentage * m_fCurrentSpeedModification * m_fWaterSpeedOrg;
		AccelRate	= fPercentage * m_fCurrentSpeedModification * m_fAccelRate;
	}
	else
	{
		// Calculate new speed based on current speed
		GroundSpeed *= fPercentage;
		AirSpeed	*= fPercentage;
		WaterSpeed	*= fPercentage;
		AccelRate	*= fPercentage ;
		// Track speed modification
		m_fCurrentSpeedModification *= fPercentage;

	}
}

// Development shortcut
exec function SFS( string ClassName)
{
	SFSummon(ClassName);
}

// Overwritten summon function, to provide better support
// for SpatialFear packages
exec function SFSummon( string ClassName)
{
	local class<actor> NewClass;
	local bool	bSpecialized;
	local string	strOrgClassName;

	bSpecialized	= false;
	strOrgClassName	= ClassName;

	if( !bCheatsEnabled )
		return;
	if( !bAdmin && (Level.Netmode != NM_Standalone) )
		return;

	if( instr(ClassName,".")==-1 )
		ClassName = "SpatialFear." $ strOrgClassName;
	else
		bSpecialized	= true;

	// Try package SpatialFear
	log( "Fabricate " $ ClassName );
	NewClass = class<actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		Spawn( NewClass,,,Location + 72 * Vector(Rotation) + vect(0,0,1) * 15 );
		return;
	}

	// Specialized class has already been tried
	if( bSpecialized )
		return;

	// Try package SFWeapon
	ClassName = "SFWeapon." $ strOrgClassName;
	class'SFUtils'.static.sfLogEx(5, "Fabricate " $ ClassName );
	NewClass = class<actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		Spawn( NewClass,,,Location + 72 * Vector(Rotation) + vect(0,0,1) * 15 );
		return;
	}

	// Try package SFItem
	ClassName = "SFItem." $ strOrgClassName;
	class'SFUtils'.static.sfLogEx(5, "Fabricate " $ ClassName );
	NewClass = class<actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		Spawn( NewClass,,,Location + 72 * Vector(Rotation) + vect(0,0,1) * 15 );
		return;
	}

	// Try package SFDecos
	ClassName = "SFDecos." $ strOrgClassName;
	class'SFUtils'.static.sfLogEx(5, "Fabricate " $ ClassName );
	NewClass = class<actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		Spawn( NewClass,,,Location + 72 * Vector(Rotation) + vect(0,0,1) * 15 );
		return;
	}

	// Try package SFCharacter
	ClassName = "SFCharacter." $ strOrgClassName;
	class'SFUtils'.static.sfLogEx(5, "Fabricate " $ ClassName );
	NewClass = class<actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		Spawn( NewClass,,,Location + 72 * Vector(Rotation) + vect(0,0,1) * 15 );
		return;
	}

	// Try package SFCharacter
	ClassName = "SFCharacter2." $ strOrgClassName;
	class'SFUtils'.static.sfLogEx(5, "Fabricate " $ ClassName );
	NewClass = class<actor>( DynamicLoadObject( ClassName, class'Class' ) );
	if( NewClass!=None )
	{
		Spawn( NewClass,,,Location + 72 * Vector(Rotation) + vect(0,0,1) * 15 );
		return;
	}

	// Call to base class
	Super.summon(strOrgClassName);
}

// Adjusts the falling height, where the player
// starts talking falling damage default value 750
exec function SFSafeFallDamage(int nValue)
{
	SafeFall_Damage = nValue;
}

// Adjusts the falling height, where the player
// is being killed default value 1650
exec function SFSafeFallKill(int nValue)
{
	SafeFall_Kill = nValue;
}

// Adjusts jumping height of a player
// default value 370
exec function SFJumpHeight(int nValue)
{
	JumpZ = nValue;
}

// toggles on/off Spatial Fear stat logging
exec function SFStat(string strType)
{
	// Make all uppercase
	strType	= Caps(strType);

	// Comparisions for our STATS
	if((strType == "PLAYER") || (strTYPE == "ALL"))
		bStatPlayer = !bStatPlayer;
	if((strType ==  "WEAPON") || (strTYPE == "ALL"))
		bStatWeapon = !bStatWeapon;
	if((strType ==  "INVENTORY") || (strTYPE == "ALL"))
		bStatInventory = !bStatInventory;
}

// prints the current spatial fear code version to the log
// and client window
exec function SFVersion()
{
	if(strSFVersion != "")
		ClientMessage( "Spatial Fear V"$strSFVersion  );
}

// sets the spatial fear log level
exec function SFLogLevel( int nLevel)
{
	class'SFUtils'.default.LogLevel=nLevel;
}

exec function Climb(Bool B)
{
	if(B)
		GotoState('Climbing');
	else
		GotoState(PlayerReStartState);
}

// Cancels an active HUD communication window
exec function CancelComm()
{
	local SFHud	sfHud;

	sfHud = SFHUD(myHUD);
	sfHud.cancelComm();
}

// exec function for Next Item binding
exec function NextItem()
{
	local SFHud	sfHud;

	sfHud = SFHUD(myHUD);
	if(None != sfHud)
		sfHud.nextItem();
}

// exec function for Previous Item binding
exec function PrevItem()
{
	local SFHud	sfHud;

	sfHud = SFHUD(myHUD);
	if(None != sfHud)
		sfHud.prevItem();
}

// exec function to show/hide the passive item window
exec function PassivItem()
{
	local SFHud	sfHud;

	sfHud = SFHUD(myHUD);
	if(None != sfHud)
		sfHud.passiveItem();
}

// exec function to print out the goaltable
exec function SFPrintGoals()
{
	m_oGoals.printTable();
}

// exec function to set a goal
exec function SFSetGoal(int nIndex)
{
	m_oGoals.setGoal(nIndex);
}

// exec function to reset a goal
exec function SFResetGoal(int nIndex)
{
	m_oGoals.resetGoal(nIndex);
}

// exec function for UseKey binding
exec function UseKey()
{
	if((m_bWeaponSelectOpen) || (m_bInventoryOpen))
	{
		SFHud(myHUD).activateItem();
		return;
	}

	m_bUseKey = 1;
}

// exec function for Creeping binding
exec function Creeping()
{
	class'SFUtils'.static.sfError("Should not be called, since we have changed back to input buttons !!!!");
	// m_bCreep, m_Duck are modified here
	m_bStandState +=1;
	// Check for roll over
	if(m_bStandState > 2)
		m_bStandState = 0;

	switch(m_bStandState)
	{
	case 0:
		bDuck = 0;
		m_bCreep = 0;
		break;
	case 1:
		bDuck = 1;
		m_bCreep = 0;
		break;
	case 2:
		bDuck = 0;
		m_bCreep = 1;
		break;
	default:
		bDuck = 0;
		m_bCreep = 0;
		break;
	}
}


exec function SFLoadDialog()
{
	local	int		nLeft, nTop, nWidth, nHeight;
	local	SFHUD	oHUD;

	// Manually update the savegame path
	//ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");
	//Ask to overwrite
	oHUD	= SFHUD(myHud);
	nWidth	= oHUD.m_fHUDScale	* 50;
	nHeight	= oHUD.m_fHUDScale	* 25;
	nLeft	= (oHUD.m_nCanvasClipX-nWidth)/2;
	nTop	= (oHUD.m_nCanvasClipy-nHeight)/2;

	// Bring up the window
	oHUD.openWindow(class'SFLoadGameWindow', nLeft, nTop, nWidth, nHeight);
}

exec function SFSaveDialog()
{
	local	int		nLeft, nTop, nWidth, nHeight;
	local	SFHUD	oHUD;

	// Manually update the savegame path
	//ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");
	//Ask to overwrite
	oHUD	= SFHUD(myHud);
	nWidth	= oHUD.m_fHUDScale	* 50;
	nHeight	= oHUD.m_fHUDScale	* 25;
	nLeft	= (oHUD.m_nCanvasClipX-nWidth)/2;
	nTop	= (oHUD.m_nCanvasClipy-nHeight)/2;

	// Bring up the window
	oHUD.openWindow(class'SFSaveGameWindow', nLeft, nTop, nWidth, nHeight);
}



// Opens up the conversation history window
exec function SFShowConvHistory()
{
	local	int		nLeft, nTop, nWidth, nHeight;
	local	SFHUD	oHUD;

	if ( (Health > 0) && (Level.NetMode == NM_Standalone))
	{
		//Show the dialog
		oHUD	= SFHUD(myHud);
		nWidth	= oHUD.m_fHUDScale	* 50;
		nHeight	= oHUD.m_fHUDScale	* 25;
		nLeft	= (oHUD.m_nCanvasClipX-nWidth)/2;
		nTop	= (oHUD.m_nCanvasClipy-nHeight)/2;

		// Bring up the window
		oHUD.openWindow(class'SFMenuConversationRecallWindow', nLeft, nTop, nWidth, nHeight);
	}
}

// Opens up the quicksave dialog
exec function SFQuickSave()
{
	local	int		nLeft, nTop, nWidth, nHeight;
	local	SFHUD	oHUD;

	if ( (Health > 0) && (Level.NetMode == NM_Standalone))
	{
		// Manually update the savegame path
	    //ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");
		//Ask to overwrite
		oHUD	= SFHUD(myHud);
		nWidth	= oHUD.m_fHUDScale	* 50;
		nHeight	= oHUD.m_fHUDScale	* 25;
		nLeft	= (oHUD.m_nCanvasClipX-nWidth)/2;
		nTop	= (oHUD.m_nCanvasClipy-nHeight)/2;

		// Bring up the window
		oHUD.openWindow(class'SFQuickSaveBox', nLeft, nTop, nWidth, nHeight);
	}
}

exec function autoSaveGame()
{
	m_nLastSaveSlot = 9999;
	//ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");
	ConsoleCommand("SaveGame " $ 9999 );
}

exec function autoLoadGame()
{
	//ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");

	if  (Level.NetMode == NM_Standalone)
		ClientTravel( "?load=9999", TRAVEL_Absolute, true);
}

function saveGame(int nNumber)
{
	m_nLastSaveSlot=nNumber;

	ConsoleCommand("SaveGame " $ nNumber);
	if(9 == nNumber)
		ClientMessage("Quick Saving ...");
	else
		ClientMessage("Saving game ...");

}

exec function loadGame(int nNumber)
{
	local int nOldSlot;

	nOldSlot = m_nLastSaveSlot;
	//ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");

	if  (Level.NetMode == NM_Standalone)
		ClientTravel( "?load="$nNumber, TRAVEL_Absolute, true);

	m_nLastSaveSlot = nOldSlot;

}

exec function SFQuickLoad()
{
	local string	strSavePath;

	strSavePath = ConsoleCommand("get core.system savepath");
    //ConsoleCommand("set core.system savepath ..\\spatial-fear\\Save");

	ClientMessage("");
	if  (Level.NetMode == NM_Standalone)
		ClientTravel( "?load=9", TRAVEL_Absolute, true);
	ClientMessage("Quick Loading");
}


/////////////////
// Global functions
/////////////////

function showHUD(bool bEnable)
{
	// We are positive here, but negative in HUD, sorry.
	SFHUD(myHUD).m_bHideStatus = !bEnable;
}

function sweat(float fDelta)
{
	local SFPheromone oParticle;

	m_fLastPheromoneSpawn += fDelta;
	if(m_fLastPheromoneSpawn > 1.5f)
	{
		m_fLastPheromoneSpawn = 0.0f;
		oParticle	= Spawn(class'SFPheromone');
		oParticle.m_actInstigator = Self;
		if(m_bViewScent)
			oParticle.bHidden = false;
	}

}

// Manually fires the actors event
function FireCustomEvent( actor Other , Pawn Instigator, name nameEvt)
{
	local actor A;

	if( Instigator.IsA('SFPlayer') )
	{
		// Broadcast the Trigger message to all matching actors.
		if( nameEvt != '' )
		{
			foreach AllActors( class 'Actor', A, nameEvt )
				A.Trigger( Other, Instigator );
		}
	}
}

event HeadZoneChange(ZoneInfo newHeadZone)
{
	// Ignore drowning when not set
	if(!m_bCannotDrown)
		Super.HeadZoneChange(newHeadZone);
}

function TakeDamage( int Damage, Pawn instigatedBy, Vector hitlocation, Vector momentum, name damageType)
{
	local int nNewDamage;

	// Check for availability of smart vest
	if(None != m_oSmartVest)
		nNewDamage = m_oSmartVest.calcDamage(Damage, string(damageType));
	else
		nNewDamage = Damage;

	Super.TakeDamage(nNewDamage, instigatedBy, hitlocation, momentum, damageType);

	// Get of carried item
	SlipDecoration();

	//class'SFUtils'.static.sfLogEx(5, "SFPlayer - TakeDamage: Damage " $ Damage $ " NewDamage " $ nNewDamage  $ " DamageType: " $ damageType);

}

// Retrieves the human readable name of the current
// player state
function string getPlayerState()
{
	switch(PlayerState)
	{
	case STATE_Crouch:
		return ("Crouching");
		break;
	case STATE_Creep:
		return ("Creeping");
		break;
	case STATE_Climb:
		return ("Climbing");
		break;
	case STATE_Swim:
		return ("Swimming");
		break;
	case STATE_Normal:
		return ("Standing");
		break;
	default:
		return ("UNDEFINED");
	}

	return ("Unknown");
}

// Retrieves the human readable name of the current
// player state
function string getStartingPlayerState()
{
	switch(StartingPlayerState)
	{
	case STATE_Crouch:
		return ("Crouching");
		break;
	case STATE_Creep:
		return ("Creeping");
		break;
	case STATE_Climb:
		return ("Climbing");
		break;
	case STATE_Swim:
		return ("Swimming");
		break;
	case STATE_Normal:
		return ("Standing");
		break;
	default:
		return ("UNDEFINED");
	}

	return ("Unknown");
}



event ClientMessage( coerce string S, optional Name Type, optional bool bBeep )
{
	if (Player == None)
		return;

	if (Type == '')
		Type = 'Event';

	if (Player.Console != None)
	{
		Player.Console.Message( PlayerReplicationInfo, S, Type );
	}
	if (bBeep && bMessageBeep)
		PlayBeepSound();
	if ( myHUD != None )
	{
		myHUD.Message( PlayerReplicationInfo, S, Type );
	}
}

// Prompts an error message to the client
function sfClientError(string strMessage)
{
	ClientMessage("SF Error: " $ strMessage);
}

// Prompts a warning message to the client
function sfClientWarning(string strMessage)
{
	ClientMessage("SF Warning: " $ strMessage);
}

// Plays the kneel animaion
function PlayKneel()
{
	BaseEyeHeight = -5;
	if ( (Weapon == None) || (Weapon.Mass < 20) )
//		TweenAnim('SwimSM', 0.25);
		TweenAnim('Crawl', 0.25);
	else
//		TweenAnim('SwimLG', 0.25);
		TweenAnim('Crawl', 0.25);
}

// Plays the creeping animation
function PlayCreeping()
{
	BaseEyeHeight = -5;

	if ( (Weapon == None) || (Weapon.Mass < 20) )
//		LoopAnim('SwimSM');
		LoopAnim('Crawl');
	else
//		LoopAnim('SwimLG');
		LoopAnim('Crawl');
}


// enables RL wipe for pawn
function setLRWipe()
{
	m_screenEffect = EFFECT_LR_WIPE;
}

// Increases the wipe boundary
function updateLRWipe()
{
	if(m_nXWipePos < 3000) // should be sufficient for nowadays monitors
		m_nXWipePos +=40;
}

// Resets any screen effect
function resetScreenEffect()
{
	m_screenEffect = EFFECT_NONE;
}

// Called from zone or trigger, when character enters
// a speedzone
function SpeedZoneEntered(float fAcceleration)
{
	// Adjust speed on ladder
	SFPlayerSpeed(fAcceleration, true);
}

// Called from zone or trigger, when character leaves
// a speedzone
function SpeedZoneLeaving(float fAcceleration)
{
	// Adjust speed on ladder
	SFPlayerSpeed(1.0/fAcceleration, true);
}


// Called from zone or trigger, when character enters
// a climbzone
function ClimbZoneEntered(float fLadderSpeedAcceleration)
{
	// Adjust speed on ladder
	SFPlayerSpeed(fLadderSpeedAcceleration, true);

	// Switch to state climbing
	if('Dying' != GetStateName())
		GotoState('Climbing');
}

// Called from zone or trigger, when character leaves
// a climbzone
function ClimbZoneLeaving(float fLadderSpeedAcceleration)
{
	// Adjust speed after leaving ladder
	SFPlayerSpeed(1.0/fLadderSpeedAcceleration, true);

	// Goto default state
	SwitchToDefaultState();
}

// Goto default player state
function SwitchToDefaultState()
{
	GotoState(PlayerReStartState);
}

// Adjust the weapon characteristics, according to the new player state
function AdjustWeaponStuff(EPlayerState state)
{
	// First time we are going down, put the weapon down.
	if((PlayerState != STATE_Creep) && (state == STATE_Creep))
	{
		// If holding a weapon, put it down
		if(None != weapon)
		{
			weapon.PutDown();

			// class'SFUtils'.Static.sfLogEx(5, "SFPlayer AdjustWeaponStuff - Putting down the weapon");
		}








	}
}

// Adjust collision characteristics for player staste
function bool AdjustCollisionStuff(EPlayerState state)
{
	// ATTENTION: When changing to CREEP state, no PIVOT correction is done!1
	// This is because I want the swimming animation to take place nearer to the ground
	// Maybe someday someone can make a creep animation, as seen in the Unreal2 videos

	local bool	bReturn;
	local float fDiff;
	local int	nDiff;
	local vector	vectOffset;

	bReturn = true;

	if(PlayerState == state)
		return true; // Nothing to do

	switch(state)
	{
		case STATE_Crouch:
			// First check for collision
			if(CheckStandUp(fDiffCrouchCreep) || (PlayerState==STATE_Normal))
			{
				// class'SFUtils'.Static.sfLogEx(5,"SFPlayer - AdjustCollisionStuff: New state: STATE_Crouch");
				// Modify bounding cylinder
				SetCollisionSize(CollisionRadius,CollisionHeightCrouch);
				// Adjust speed in new state
				SFPlayerSpeed(Default.CrouchSpeed);
				// Compensate mesh origin
				if(PlayerState == STATE_Normal)
					PrePivot.Z += fDiffStandCrouch;
				else if(PlayerState == STATE_Creep)
				{
					PrePivot.Z = PrePivot.Z;		// Not correcting, just changing collision height
//					PrePivot.Z -= fDiffCrouchCreep;
				}
				// Correct the location center, to prevent falling through decoration
				if(PlayerState == STATE_Creep)
				{
					vectOffset = vect(0,0,0);
					vectOffset.Z += int(fDiffCrouchCreep);
					SetLocation(Location + vectOffset);
				}
				// Update state
				PlayerState = STATE_Crouch;
			}
			else
			{
				//class'SFUtils'.Static.sfLogEx(5,"SFPlayer - AdjustCollisionStuff: Cannot switch to STATE_CROUCH: collision");
				bReturn = false;
			}
		break;
		case STATE_Creep:
			//class'SFUtils'.Static.sfLogEx(5,"SFPlayer - AdjustCollisionStuff: New state: STATE_Creep");
			// Modify bounding cylinder
			SetCollisionSize(CollisionRadius,CollisionHeightCreep);
			// Adjust speed in new state
			SFPlayerSpeed(Default.CreepSpeed);
			// Compensate mesh origin

			if(PlayerState == STATE_Normal)
//				PrePivot.Z = PrePivot.Z;
				PrePivot.Z += fDiffStandCrouch;		// Only use PrePivot correciton based on crouch
			else if(PlayerState == STATE_Crouch)
				PrePivot.Z = PrePivot.Z; // Not correcting, just changing collision height
//				PrePivot.Z += fDiffCrouchCreep;
			// Update state
			PlayerState = STATE_Creep;
		break;
		case STATE_Normal:
			// Determine transition kind
			if(StartingPlayerState == STATE_Crouch)
				fDiff = fDiffStandCrouch;
			else if (StartingPlayerState == STATE_Creep)
				fDiff = fDiffStandCreep;
			nDiff = int(fDiff);

			// First check for collision
			if(CheckStandUp(fDiff))
			{
				//class'SFUtils'.Static.sfLogEx(5,"SFPlayer - AdjustCollisionStuff: New state: STATE_Normal");
				// Reset collision cylinder
				SetCollisionSize(CollisionRadius,Default.CollisionHeight);
				// Adjust speed in new state
				SFPlayerSpeed(Default.NormalSpeed);
				// Update PrePivot
				PrePivot.Z = m_fInitialPrePivotZ;	// Return to initial
				// Correct the location center, to prevent falling through decoration
				vectOffset = vect(0,0,0);
				vectOffset.Z += nDiff;
				SetLocation(Location + vectOffset);
				// Update state
				PlayerState = STATE_Normal;
			}
			else
			{
				//class'SFUtils'.Static.sfLogEx(5,"SFPlayer - AdjustCollisionStuff: Cannot switch to STATE_NORMAL: collision");
				bReturn = false;
			}

		break;
	}
	return bReturn;
}



// Base class override to prevent footsteps during creeping
simulated function FootStepping()
{
	local sound				step;
	local float				decision;
	local Texture			texCurrent;
	local SFPlayerShadow	oShadow;

	// No sound during creeping
	if(m_bIsCreeping)
		return;

	if ( FootRegion.Zone.bWaterZone )
	{
		PlaySound(WaterStep, SLOT_Interact, 1, false, 1000.0, 1.0);
		return;
	}

	// Extract ground texture






	step	= None;
	if(None != Shadow)
	{
		texCurrent	= (SFPlayerShadow(Shadow)).m_texCurrent;
		if(None != texCurrent)
			step = texCurrent.FootstepSound;
	}

	// Footstep sound not assigned, yet?
	if(None == step)
	{
		// Use one of the default footstep sounds
		decision = FRand();
		if ( decision < 0.34 )
			step = Footstep1;
		else if (decision < 0.67 )
			step = Footstep2;
		else
			step = Footstep3;
	}

	PlaySound(step, SLOT_Interact, m_fFootstepVolume, false, 1000.0, 1.0);
}


exec function SoundPitch(float fPitch)
{
	fSoundPitch=fPitch;
}

function TakeFallingDamage()
{
	//class'SFUtils'.Static.sfLog("TakeFallingDamage " $ string(JumpZ) $ " " $ string(Velocity.Z));
	if (Velocity.Z < -1.4 * JumpZ)
	{
		//class'SFUtils'.Static.sfLog("Velocity.Z < -1.4 * JumpZ) " $ string(JumpZ));
		MakeNoise(-0.5 * Velocity.Z/(FMax(JumpZ, 150.0)));
		if (Velocity.Z <= (-SafeFall_Damage - JumpZ))
		{
			class'SFUtils'.Static.sfLog("Velocity.Z <= -SafeFall_Damage - JumpZ " $ string(JumpZ));
			if ( (Velocity.Z < -SafeFall_Kill - JumpZ) && (ReducedDamageType != 'All') )
			{
				//class'SFUtils'.Static.sfLog("TakeDamage(1000, None, Location, vect(0,0,0), 'Fell'); " $ string(JumpZ));
				TakeDamage(1000, None, Location, vect(0,0,0), 'Fell');
			}
			else if ( Role == ROLE_Authority )
			{
				//class'SFUtils'.Static.sfLog("Taking damage" $ string(JumpZ));
				TakeDamage(-0.15 * (Velocity.Z + (SafeFall_Damage*0.9) + JumpZ), None, Location, vect(0,0,0), 'Fell');
			}
			ShakeView(0.175 - 0.00007 * Velocity.Z, -0.85 * Velocity.Z, -0.002 * Velocity.Z);
		}
	}
	else if ( Velocity.Z > 0.5 * Default.JumpZ )
	{
		MakeNoise(0.35);
		//class'SFUtils'.Static.sfLog("Velocity.Z > 0.5 * Default.JumpZ " $ string(JumpZ));
	}
}

// Prepares the player canvas for output
function PrepareCanvas(out canvas C)
{
	// Set font
	C.Font = class'FontInfo'.Static.GetStaticSmallFont( C.ClipX );
	// Set color
	C.DrawColor.R = 25;
	C.DrawColor.G = 0;
	C.DrawColor.B = 255;
}


// Prepares the player canvas for STAT output
function PrepareCanvasStat(out canvas C)
{
	// Set font
	C.Font = class'FontInfo'.Static.GetStaticSmallestFont( C.ClipX );
	// Set color
	C.DrawColor.R = 255;
	C.DrawColor.G = 255;
	C.DrawColor.B = 255;
}

// Renders creature info
function RenderCreatureInfo(Canvas C, float fPosY)
{
	local string strCreatureData;
	local float fPosX;
	local float XL, YL;
	local ScriptedPawn	oCreature;

	if(None == pawnCreatureMonitor)
		return;

	oCreature = ScriptedPawn(pawnCreatureMonitor);
	if(None == oCreature)
		return;

	fPosX = 1;
	fPosY += 1*(YL + 2);
	C.SetPos( fPosX, fPosY );
	// Draw title and do  no CR
	C.TextSize("SFPlayer:", XL, YL);
	C.DrawText("Creature: " $ oCreature.name, false );
	// Compose debug output
	fPosY += YL + 2;
	C.SetPos(fPosX, fPosY);
	strCreatureData =  "   State: " $ oCreature.getStateName();
	if(None != oCreature.OldEnemy)
		strCreatureData = strCreatureData $ " OldEnemy: " $ oCreature.OldEnemy.name;
	else
		strCreatureData = strCreatureData $ " OldEnemy: None";
	if(None != oCreature.Hated)
		strCreatureData = strCreatureData $ " Hated: " $ oCreature.Hated.name;
	else
		strCreatureData = strCreatureData $ " Hated: None";
	if(None != oCreature.Enemy)
		strCreatureData = strCreatureData $ " Enemy: " $ oCreature.Enemy.name;
	else
		strCreatureData = strCreatureData $ " Enemy: None";
	if(None != oCreature.Target)
		strCreatureData = strCreatureData $ " Target: " $ oCreature.Target.name;
	else
		strCreatureData = strCreatureData $ " Target: None";
	C.DrawText( strCreatureData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos(fPosX, fPosY);
	strCreatureData =  "   Alertness: " $ oCreature.Alertness $ " PeripheralVision: " $ oCreature.PeripheralVision $ " HearingThreshold: " $ oCreature.HearingThreshold $ " AttitudeToPlayer: " $ oCreature.AttitudeToPlayer $ " health: " $ oCreature.health ;
	C.DrawText( strCreatureData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos(fPosX, fPosY);
	strCreatureData =  "   Orders: " $ oCreature.Orders;;
	if(None != oCreature.TeamLeader)
		strCreatureData =  strCreatureData $ " TeamLeader: " $ oCreature.TeamLeader.name;
	else
		strCreatureData =  strCreatureData $ " TeamLeader: None";
	strCreatureData =  strCreatureData $ " CombatStyle: " $ oCreature.CombatStyle;
	C.DrawText( strCreatureData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos(fPosX, fPosY);
	strCreatureData =  "   NextState : " $ oCreature.NextState $ " NextLabel: " $ oCreature.NextLabel $ " NextAnim: " $ oCreature.NextAnim;
	C.DrawText( strCreatureData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos(fPosX, fPosY);
	strCreatureData =  "   Destination: " $ oCreature.Destination $  " LastSeenPos: " $ oCreature.LastSeenPos;
	C.DrawText( strCreatureData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos(fPosX, fPosY);
	strCreatureData =  "   AnimSequenc: " $ oCreature.GetAnimGroup(AnimSequence) ;
	C.DrawText( strCreatureData, true );

}


// Renders the version info to the screen
function RenderVersionInfo(canvas C)
{
	local string strVersionInfo;
	local float fPosX, fPosY;
	local float XL, YL;

	if(strSFVersion == "")
		return;

	// Get text size
	strVersionInfo = "Spatial Fear V." $ strSFVersion;
	C.TextSize( strVersionInfo , XL, YL );
	fPosX = C.ClipX - XL -10;
	fPosY = YL + 15;
	C.SetPos( fPosX, fPosY );
	// Draw text and no CR
	C.DrawText( strVersionInfo, False );
}

// Renders the player data to the screen
function float RenderPlayerData(canvas C, float fPosY)
{
	local string strPlayerData;
	local float fPosX;
	local float XL, YL;

	fPosX = 1;
	fPosY += 1*(YL + 2);
	C.SetPos( fPosX, fPosY );
	// Draw title and do  no CR
	C.DrawText( "SFPlayer:", false );
	C.TextSize("SFPlayer:", XL, YL);
	// Compose debug output
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strPlayerData =  "   Loc(" $ class'SFUtils'.static.FormatFloat(Location.x) $ "/" $ class'SFUtils'.static.FormatFloat(Location.y) $ "/"  $ class'SFUtils'.static.FormatFloat(Location.z) $ ") ColH: " $ string(CollisionHeight) $ " ColRad: " $ string(CollisionRadius) $ " Vel(" $ class'SFUtils'.static.FormatFloat(Velocity.x) $ "/" $ class'SFUtils'.static.FormatFloat(Velocity.y)$ "/"  $ class'SFUtils'.static.FormatFloat(Velocity.z) $ ") PrePivot.Z: " $ class'SFUtils'.static.FormatFloat(PrePivot.z); // Draw text and no CR
	C.DrawText( strPlayerData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strPlayerData =  "   EyeHeight: " $ class'SFUtils'.static.FormatFloat(EyeHeight) $ " GrdSpeed: " $ class'SFUtils'.static.FormatFloat(GroundSpeed) $ " AirSpeed: " $ class'SFUtils'.static.FormatFloat(AirSpeed) $  " WaterSpeed: " $ class'SFUtils'.static.FormatFloat(WaterSpeed) $ " Accel: " $ class'SFUtils'.static.FormatFloat(AccelRate) $ " Cur. Modificator: " $ class'SFUtils'.static.FormatFloat(m_fCurrentSpeedModification);
	// Draw text and no CR
	C.DrawText( strPlayerData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strPlayerData =  "   JumpZ: " $ class'SFUtils'.static.FormatFloat(JumpZ) $ " SafeDamage: " $ class'SFUtils'.static.FormatFloat(SafeFall_Damage) $ " SafeKill: " $ class'SFUtils'.static.FormatFloat(SafeFall_Kill) $ " Health: " $ Health;
	// Draw text and no CR
	C.DrawText( strPlayerData, true );

	// Next line
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strPlayerData =  "   State: " $ GetStateName() $ " PlayerState: " $ getPlayerState() $ " FootStepVolume: " $ class'SFUtils'.static.FormatFloat(m_fFootstepVolume) $ " AccuracyUpgrade: " $ class'SFUtils'.static.FormatFloat(m_fPenaltyUpgrade) $ " UnderwaterTime: " $ UnderWaterTime;
	// Draw text and no CR
	C.DrawText( strPlayerData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strPlayerData =  "   UseKeyRange: " $ SFGameInfo(Level.Game).nUseKeyRange;
	// Draw text and no CR
	C.DrawText( strPlayerData, true );
	// Next line
	fPosY += YL + 2;


	return fPosY;
}

// Renders the current weapon data to the screen
function float RenderWeaponData(canvas C, float fPosY)

{
	local string strWeaponData;
	local float fPosX;

	local float XL, YL;
	local SFWeapon	oWeap;

	// Cast to SFWeapon
	oWeap = SFWeapon(Weapon);

	if(None == oWeap)
		return fPosY;

	fPosX = 1;
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	// Draw title and do  no CR
	C.DrawText( "SFWeapon:", false );
	C.TextSize("SFWeapon:", XL, YL);
	// Compose debug output
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strWeaponData =  "   Aimerror: " $ class'SFUtils'.static.FormatFloat(oWeap.AimError) $ " AccuracyPenalty: " $ class'SFUtils'.static.FormatFloat(oWeap.AccuracyPenalty) $ " RateOfFire: " $ class'SFUtils'.static.FormatFloat(oWeap.fDesiredRate) $ " SemiAuto: " $ oWeap.m_bSemiAuto $ " SemiAutoAlt: " $ oWeap.m_bSemiAutoAlt ; // Draw text and no CR
	C.DrawText( strWeaponData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strWeaponData = "   ProjRange: " $ oWeap.nProjRange $ " ProjLifSpan: " $ oWeap.fProjLifeSpan $ " AltMode: " $ oWeap.m_bAltMode $ " ProjectileSpeed: " $ class'SFUtils'.static.FormatFloat(oWeap.ProjectileSpeed) $ " AltProjectileSpeed: " $ class'SFUtils'.static.FormatFloat(oWeap.AltProjectileSpeed) ;
	C.DrawText( strWeaponData, true );
	// Next line
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strWeaponData = "   State: " $ oWeap.GetStateName()  ;
	C.DrawText( strWeaponData, true );

	fPosY += YL + 2;
	return fPosY;
}

// Renders the current inventory data to the screen
function float RenderInventoryData(canvas C, float fPosY)
{
	local string strInvData;
	local float fPosX;
	local float XL, YL;
	local SFDamageProtection	oItem;

	// Cast to SFWeapon
	oItem = m_oSmartVest;
	if(None == oItem)
		return fPosY;

	fPosX = 1;
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	// Draw title and do  no CR
	C.DrawText( "SFInventory:", false );
	C.TextSize("SFInventory:", XL, YL);
	// Compose debug output
	fPosY += YL + 2;
	C.SetPos( fPosX, fPosY );
	strInvData =  "   SmartVest: HealthAmount: "  $ oItem.HealingAmount $ "("$ oItem.MaxHealing $ ") FireProtect: " $ class'SFUtils'.static.FormatFloat(oItem.m_fFireProtection) $ " ChemProtect: " $ class'SFUtils'.static.FormatFloat(oItem.m_fChemicalProtection) $ " ShotProtect: " $ class'SFUtils'.static.FormatFloat(oItem.m_fBallisticProtection) $ " RadioProtect: " $ class'SFUtils'.static.FormatFloat(oItem.m_fRadioactiveProtection) $ " MaxProtect: " $ class'SFUtils'.static.FormatFloat(oItem.m_fMaxProtection); // Draw text and no CR
	C.DrawText( strInvData, true );
}

	simulated function ClimbStepping()
{
	PlaySound(ClimbStep, SLOT_Interact, 1, false, 1000.0, 1.0);
}

function RenderScreenEffect(canvas C)
{
	switch(m_screenEffect)
	{
	case EFFECT_LR_WIPE:
		C.DrawTile( texture'BlackTexture', FMin(m_nXWipePos,C.ClipX), C.ClipY, 0, 0, 256, 256 );
		break;
	}
}




////////////////////////
// Events
////////////////////////
event  Detach(Actor o)
{
	Super.Detach(o);
}

// Do some cleanup here
event  Expired()
{
	local int i;

	Super.Expired();

	// Free some references

}

simulated event UnPossess()
{
	Super.UnPossess();
	//class'SFUtils'.Static.sfLogEx(5, "SFPlayer - UnPossess :");

}


// Called when the actor is possesed
simulated event Possess()
{
	local WindowConsole    C;

	// Call to base class
	Super.Possess();

	C = WindowConsole(Player.Console);
	if (C.Root == None)
	{
		// Create the root window on first impact
		//class'SFUtils'.Static.sfLogEx(5, "SFPlayer Possess - C.Root == None - Creating Root");
		C.CreateRootWindow(None);
	}

	if (Player != None	&& Player.Console != None  && UTConsole(Player.Console) != None
		&& (UTConsole(Player.Console).Speechwindow == None	|| !UTConsole(Player.Console).Speechwindow.IsA('SFSpeechWindow')) )
	{
		// Create our own speech window
		Root = WindowConsole(Player.Console).Root;

		if (UTConsole(Player.Console).Speechwindow != None)
		{
			UTConsole(Player.Console).Speechwindow.Close();
			UTConsole(Player.Console).Speechwindow.CancelAcceptsFocus();
		}

		UTConsole(Player.Console).Speechwindow = None;
/*
		UTConsole(Player.Console).Speechwindow = SpeechWindow(Root.CreateWindow(Class'SFSpeechWindow', 100, 100, 200, 200));
		Song = None;
		if (UTConsole(Player.Console).Speechwindow == None)
		{
			class'SFUtils'.Static.sfLogEx(5, "SFPlayer Possess - Failed to create speechwindow");
			return;
		}

		UTConsole(Player.Console).SpeechWindow.bLeaveOnScreen = true;

		if(UTConsole(Player.Console).bShowSpeech)
		{
			Root.SetMousePos(0, 132.0/768 * Root.WinWidth);
			UTConsole(Player.Console).SpeechWindow.SlideInWindow();
		}
		else
			UTConsole(Player.Console).SpeechWindow.HideWindow();
*/
	}
}

// Saves the current input modifiers
function SaveInput()
{
	m_bSavedDuck	= bDuck;
	m_bSavedCreep	= m_bCreep;
}

// Restores the current input modifiers from the saved ones
function RestoreInput()
{
	bDuck		= m_bSavedDuck;
	m_bCreep	= m_bSavedCreep;
}

// Resets the current input
function ResetInput()
{
	bDuck		= 0;
	m_bCreep	= 0;
}

// Sets the input variables for the normal state: WALKING
function SetNormalInput()
{
	bDuck			= 0;
	m_bCreep		= 0;
	m_bManualInput	= true;
}

// Sets the input variables for the crouch state: DUCK
function SetCrouchInput()
{
	SaveInput();
	bDuck			= 1;
	m_bCreep		= 0;
	m_bManualInput	= true;
}

// Sets the input variables for the creep state: CREEPING
function SetCreepInput()
{
	SaveInput();
	bDuck			= 0;
	m_bCreep		= 1;
	m_bManualInput	= true;
}

//Resets the manual modifications to the input state
function ResetManualInput()
{
	// Early out
	if(!m_bManualInput)
		return;

	ResetInput();

	m_bManualInput	= false;
}

event PlayerInput( float DeltaTime )
{
	local bool bTryingToStandUp ;
	// Call to base class
	Super.PlayerInput(DeltaTime);

	// Save the current starting state
	StartingPlayerState = PlayerState;

	if(m_bUseKey==1)
	{
		UseKeyTargetting();
		// Reset key
		m_bUseKey = 0;
	}

	// Cannot creep or crawl while carrying something
	if(None != CarriedDecoration)
	{
		m_bCreep	= 0;

		bDuck		= 0;
	}

	if(m_bCreep==1)
	{
		AdjustWeaponStuff(STATE_Creep);
		AdjustCollisionStuff(STATE_Creep);
	}
	else if(bDuck==1)
	{

		// Try to go to duck state
		if(!AdjustCollisionStuff(STATE_Crouch))
		{
			SetCreepInput();
			AdjustCollisionStuff(STATE_Creep);
		}
	}
	else
	{
		if(PlayerState != STATE_Normal)
			bTryingToStandUp = true;

		if(!AdjustCollisionStuff(STATE_Normal))
		{
			SetCrouchInput();
			if(!AdjustCollisionStuff(STATE_Crouch))
			{
				SetCreepInput();
				AdjustCollisionStuff(STATE_Creep);
			}
		}
		else
		{
			if(bTryingToStandUp)
			{
				if(None != m_oCreepPendingWeapon)
				{
					Weapon=m_oCreepPendingWeapon;
					m_oCreepPendingWeapon=None;
					Weapon.BringUp();
				}
			}
		}
	}
}


event PostRender( canvas C )
{
	local texture tex;
	local float fYPos;

	fYPos = 1;
	if(None != C)
	{
		if( m_screenEffect != EFFECT_NONE)
			RenderScreenEffect(C);

		PrepareCanvas(C);
		if(bShowVersionInfo)
			RenderVersionInfo(C);

		if(bStatPlayer)
		{
			PrepareCanvasStat(C);
			fYPos = RenderPlayerData(C, fYPos);
		}
		if(bStatWeapon)
		{
			PrepareCanvasStat(C);
			fYPos = RenderWeaponData(C, fYPos);
		}
		if(bStatInventory)
		{
			PrepareCanvasStat(C);
			fYPos = RenderInventoryData(C, fYPos);
		}
		RenderCreatureInfo(C, fYPos);

		// Eventully do medstation readout
		renderMedStationContact(C);
	}

	Super.PostRender(C);

//	SizeX, SizeY
}

function renderMedStationContact(Canvas C)
{
	local float XL, YL;
	local bool bFound;
	local int X, Y;
	local SFPlayer oPlayer;

	// Check for current contact
	if(None == m_actNearestMedStation)
		return;

	bFound = false;
	foreach RadiusActors(class'SFPlayer', oPlayer, m_actNearestMedStation.RefillRadius+3, m_actNearestMedStation.Location)
	{
		if(oPlayer == Self)
			bFound = true;
	}

	if(!bFound)
		// Release contact
		m_actNearestMedStation = None;

	// Prepare canvas
	C.Style = ERenderStyle.STY_Translucent;
	C.Font	= SFHUD(myHud).m_Fonts.GetSmallFont(C.ClipX );
	C.DrawColor.R = 210;

	C.DrawColor.G = 80;
	C.DrawColor.B = 30;

	X = C.ClipX/3;
	Y = C.ClipY/10;
	C.StrLen("Med", XL, YL);
	C.SetPos(X, Y);
	C.DrawText("MedStation Link established ...");
	Y += YL;
	C.SetPos(X, Y);
	if(m_actNearestMedStation.Broken)
		C.DrawText("   Status: Not Functional.");
	else
		C.DrawText("   Status: Functional.");
	Y += YL;
	C.SetPos(X, Y);
	C.DrawText("   Remaining Health: " $ m_actNearestMedStation.HealingAmount);
	Y += 2*YL;
	C.SetPos(X, Y);
	C.DrawText("Current Health: " $ Health);
	if(None != m_oSmartVest)
	{
		Y += YL;
		C.SetPos(X, Y);
		C.DrawText("Current Smart Vest Reservoir: " $ m_oSmartVest.HealingAmount);
	}

}

// Called when the player wants to jump
function DoJump( optional float F )
{
	if ((CarriedDecoration != None) && (CarriedDecoration.Mass > 20))
		return;

	// Only do jump when we are not creeping
	if(!m_bIsCreeping)
		Super.DoJump(F);
	else
		class'SFUtils'.Static.sfLogEx(5,"Jumping not possible when creeping");

}

/*
With grab functionality
function UseKeyTargetting()
{
	local vector lookDir, HitLocation, HitNormal, T1, T2, extent;
	local actor HitActor;
	local SFPickup			oPickUpObj;
	local SFUseKeyTrigger	oTrigObj;
	local SFMover			oMoverObj;


	//first trace to find it
	lookDir = vector(Rotation);
	lookDir.Z = 0;
	T1 = Location + BaseEyeHeight * vect(0,0,1) + lookDir * 0.8 * CollisionRadius;
	T2 = T1 + lookDir * 1.2 * CollisionRadius;
	HitActor = Trace(HitLocation, HitNormal, T2, T1, true);
	if ( HitActor == None )
	{
log("Nothing found for the first trace");
		T1 = T2 - (BaseEyeHeight + CollisionHeight - 2) * vect(0,0,1);
		HitActor = Trace(HitLocation, HitNormal, T1, T2, true);
	}
	else if ( HitActor == Level )
	{
log("Level found for the first trace");

		T2 = HitLocation - lookDir;
		T1 = T2 - (BaseEyeHeight + CollisionHeight - 2) * vect(0,0,1);
		HitActor = Trace(HitLocation, HitNormal, T1, T2, true);
	}
	if ( (HitActor == None) || (HitActor == Level) )
	{
log("Nothing or level found for the second trace: " $ HitActor.name);






		extent.X = CollisionRadius;
		extent.Y = CollisionRadius;
		extent.Z = CollisionHeight;
		HitActor = Trace(HitLocation, HitNormal, Location + lookDir * 1.2 * CollisionRadius, Location, true, extent);
	}

	// Check if something was found
	if(None == HitActor)
		return;
log("Found HitActor: " $ HitActor.name);
	// Check for UseKeyTrigger
	if(HitActor.IsA('SFUseKeyTrigger'))
	{
		oTrigObj	= SFUseKeyTrigger(HitActor);
		class'SFUtils'.Static.sfLogEx(12,"SFPlayer - UseKeyTargetting: Actor in range: " $ oTrigObj.name);
		if(oTrigObj.IgnoreTouching)
		{
			class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found UseKeyTrigger, calling FireEvent");
    		oTrigObj.FireEvent(self);

			return; // Do not continue
		}
	}

	// Check for SFMover
	if(HitActor.IsA('SFMover'))
	{
		oMoverObj	= SFMover(HitActor);
		class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Actor in range: " $ oMoverObj.name);
		if(oMoverObj.IgnoreBumping)
		{
			class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFMover, calling ManualBump");
			if(oMoverObj.IsInState('TriggerToggle'))
				oMoverObj.ManualTrigger(self);
			else
    			oMoverObj.ManualBump(self);

			return; // Do not continue
		}
	}

	// Using TraceActors and a 10x10x10 cube for the extents
	if(HitActor.IsA('SFPickup'))
	{
		oPickUpObj	= SFPickup(HitActor);
		class'SFUtils'.Static.sfLogEx(12,"SFPlayer - UseKeyTargetting: Actor in range: " $ oPickUpObj.name);
		if(oPickUpObj.bManualPickup)
		{
			class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFPickup, picking it  up.");
			// Mark the pickup as "usekey accessed"
			oPickupObj.bUseKeyHit = true;
			// Pickup the object
			oPickupObj.Touch(self);
			// Reset the "usekey accessed" flag
			oPickupObj.bUseKeyHit = false;

			// Do not continue
			return;
		}
	}
}
*/
/*
My original

//
function UseKeyTargetting()
{
	local vector HitLoc, HitNorm, End, X, Y, Z, Start;
	local actor Other ;
	local rotator rotAdjustAim;
	local rotator rotAiming;
	local SFMover			oMoverObj;
	local SFUseKeyTrigger	oTrigObj;
	local SFPickup			oPickUpObj;

	// Get vectors for where the player is aiming on each axis
	GetAxes(ViewRotation, X, Y, Z);

	// Calculate starting location
	Start = Location + 0.5*EyeHeight * vect(0,0,1);
	rotAiming = ViewRotation;

	// Using an arbitrary range of 100 UUs
	End = Start + (UseKeyRange *  vector(rotAiming));

	class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargeting: Start: (" $ Start.x $ "/" $ Start.y $ "/" $ Start.z $") End: (" $ End.x $ "/" $ End.y $ "/" $ End.z $")" );

	// Using TraceActors and a 10x10x10 cube for the extents
	foreach TraceActors(class'SFUseKeyTrigger', oTrigObj, HitLoc, HitNorm, End, Start, ) //vect(10.0, 10.0, 10.0))
	{
		class'SFUtils'.Static.sfLogEx(12,"SFPlayer - UseKeyTargetting: Actor in range: " $ oTrigObj.name);
		if(None != oTrigObj)
		{
			if(oTrigObj.IsA('SFUseKeyTrigger') && oTrigObj.IgnoreTouching)
			{
				class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found UseKeyTrigger, calling FireEvent");
    			oTrigObj.FireEvent(self);

				return; // Do not continue
			}

		}
	}

	// Trace for movers
	foreach TraceActors(class'SFMover', oMoverObj, HitLoc, HitNorm, End, Start , vect(10.0, 10.0, 10.0))
	{
		class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Actor in range: " $ oMoverObj.name);
		if(None != oMoverObj)
		{
			if(oMoverObj.IsA('SFMover') && oMoverObj.IgnoreBumping)
			{
				class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFMover, calling ManualBump");
				if(oMoverObj.IsInState('TriggerToggle'))
					oMoverObj.ManualTrigger(self);
				else
    				oMoverObj.ManualBump(self);

				return; // Do not continue
			}

		}
	}

	// Using TraceActors and a 10x10x10 cube for the extents
	foreach TraceActors(class'SFPickup', oPickUpObj, HitLoc, HitNorm, End, Start, ) //vect(10.0, 10.0, 10.0))

	{
		if(None != oPickUpObj)
		{
			class'SFUtils'.Static.sfLogEx(12,"SFPlayer - UseKeyTargetting: Actor in range: " $ oPickUpObj.name);
			if(oPickUpObj.IsA('SFPickup'))
			{
				if(oPickUpObj.bManualPickup)



				{
					class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFPickup, picking it  up.");
					// Mark the pickup as "usekey accessed"
					oPickupObj.bUseKeyHit = true;
					// Pickup the object
					oPickupObj.Touch(self);
					// Reset the "usekey accessed" flag
					oPickupObj.bUseKeyHit = false;

					// Do not continue
					return;
				}
			}
		}
	}
}
*/

// Retrieves the angle between the two given vectors in radians
function float getAngle(vector vecFirst, vector vecSecond)
{
	return Normal(vecFirst) dot Normal(vecSecond);
}


// Brings up an invisible gun
function raiseNullGun()
{
	local Weapon	oNullGun;


	oNullGun = Weapon(FindInventoryType(class'SFNullGun'));
	if(None == oNullGun)
		// Spawn the null gun
		PendingWeapon = spawn(class'SFNullGun', Owner);
	else
		PendingWeapon = oNullGun;

	if(None != Weapon)
	{
		m_oNullWeaponRestore	= Weapon;
		Weapon.PutDown();
	}
}

function putDownNullGun()
{
	local Weapon	oNullGun;

	if(None != m_oNullWeaponRestore)
	{
		PendingWeapon			= m_oNullWeaponRestore;
		m_oNullWeaponRestore	= None;
		ChangedWeapon();
	}

	oNullGun = Weapon(FindInventoryType(class'SFNullGun'));
	if(None != oNullGun)
		oNullGun.Destroy();
}

// SF modifications to grab behaviour
function GrabDecoration()
{
	local vector lookDir, HitLocation, HitNormal, T1, T2, extent;
	local actor HitActor;

	// Cannot pickup while creeping
	if(m_bIsCreeping || bIsCrouching)
		return;

	if ( carriedDecoration == None )
	{
		//first trace to find it
		lookDir = vector(Rotation);
		lookDir.Z = 0;
		T1 = Location + BaseEyeHeight * vect(0,0,1) + lookDir * 0.8 * CollisionRadius;
		T2 = T1 + lookDir * 1.2 * CollisionRadius;
		HitActor = Trace(HitLocation, HitNormal, T2, T1, true);
		if ( HitActor == None )

		{

			T1 = T2 - (BaseEyeHeight + CollisionHeight - 2) * vect(0,0,1);
			HitActor = Trace(HitLocation, HitNormal, T1, T2, true);
		}
		else if ( HitActor == Level )
		{
			T2 = HitLocation - lookDir;
			T1 = T2 - (BaseEyeHeight + CollisionHeight - 2) * vect(0,0,1);
			HitActor = Trace(HitLocation, HitNormal, T1, T2, true);
		}
		if ( (HitActor == None) || (HitActor == Level) )
		{
			extent.X = CollisionRadius;
			extent.Y = CollisionRadius;
			extent.Z = CollisionHeight;
			HitActor = Trace(HitLocation, HitNormal, Location + lookDir * 1.2 * CollisionRadius, Location, true, extent);
		}

		if (Decoration(HitActor) != None )
//		if ( (Decoration(HitActor) != None)  && ((weapon == None) || (weapon.Mass < 20)) )
		{

			CarriedDecoration = Decoration(HitActor);
			if ( !CarriedDecoration.bPushable || (CarriedDecoration.Mass > 45)
				|| (CarriedDecoration.StandingCount > 0) )
			{
				CarriedDecoration = None;
				return;
			}
			lookDir.Z = 0;
			raiseNullGun();
			if ( CarriedDecoration.SetLocation(Location + (0.5 * CollisionRadius + CarriedDecoration.CollisionRadius) * lookDir) )
			{
				CarriedDecoration.SetPhysics(PHYS_None);
				CarriedDecoration.SetBase(self);
				CarriedDecoration.SetCollision(False, False, False);
				CarriedDecoration.bCollideWorld = False;
				CarriedDecoration.Style = STY_Translucent;
				CarriedDecoration.ScaleGlow = 1.0;
				CarriedDecoration.bUnlit = True;
			}
			else
			{
				putDownNullGun();
				ClientMessage("Cannot lift item.");
				CarriedDecoration = None;
			}
		}
	}
}


function SlipDecoration()
{
	if (CarriedDecoration != None)
	{

		CarriedDecoration.bWasCarried = true;
		CarriedDecoration.SetCollision(True, True, True);
		CarriedDecoration.bCollideWorld = True;
		CarriedDecoration.SetBase(None);
		CarriedDecoration.SetPhysics(PHYS_Falling);
		CarriedDecoration.Velocity = Velocity + 10 * VRand();
		CarriedDecoration.Instigator = self;
		// Restore display
		CarriedDecoration.Style = CarriedDecoration.Default.Style;
		CarriedDecoration.ScaleGlow = CarriedDecoration.Default.ScaleGlow;
		CarriedDecoration.bUnlit = CarriedDecoration.Default.bUnlit;

		CarriedDecoration = None;

		putDownNullGun();
	}















}

function DropDecoration()
{
	local Vector X, Y, Z, dropVect, origLoc, HitLocation, HitNormal, extent;
	local float velscale, size, mult;
	local bool bSuccess;
	local Actor hitActor;

	bSuccess = False;

	if (CarriedDecoration != None)
	{
		// Check for not throwabel decoration
		if(CarriedDecoration.IsA('SFDecoration'))
		{
			if(!SFDecoration(CarriedDecoration).bThrowable)
			{
				SlipDecoration();
				return;
			}
		}

		origLoc = CarriedDecoration.Location;
		GetAxes(Rotation, X, Y, Z);

		// Compute throw velocity
		CarriedDecoration.Velocity = Vector(ViewRotation) * 500 + vect(0,0,220) + 40 * VRand();
		// Scale it based on the mass
		velscale = FClamp(CarriedDecoration.Mass / 20.0, 1.0, 40.0);
		CarriedDecoration.Velocity /= velscale;

		// Calculate impcat location
		dropVect = Location + (CarriedDecoration.CollisionRadius + CollisionRadius + 4) * X;
		dropVect.Z += BaseEyeHeight;

		// Is anything blocking the drop point? (like thin doors)
		if (FastTrace(dropVect))
		{
			CarriedDecoration.SetCollision(True, True, True);
			CarriedDecoration.bCollideWorld = True;

			// Check to see if there's space there
			extent.X = CarriedDecoration.CollisionRadius;
			extent.Y = CarriedDecoration.CollisionRadius;
			extent.Z = 1;
			hitActor = Trace(HitLocation, HitNormal, dropVect, CarriedDecoration.Location, True, extent);

			if ((hitActor == None) && CarriedDecoration.SetLocation(dropVect))
				bSuccess = True;
			else
			{
				CarriedDecoration.SetCollision(False, False, False);
				CarriedDecoration.bCollideWorld = False;
			}
		}

		// Drop item and restore the view settings
		if (bSuccess)
		{
			CarriedDecoration.bWasCarried = True;
			CarriedDecoration.SetBase(None);
			CarriedDecoration.SetPhysics(PHYS_Falling);
			CarriedDecoration.Instigator = Self;


			// Turn off translucency
			CarriedDecoration.Style = CarriedDecoration.Default.Style;

			CarriedDecoration.bUnlit = CarriedDecoration.Default.bUnlit;
			CarriedDecoration = None;

			putDownNullGun();
		}
		else
		{
			// otherwise, don't drop it and display a message
			CarriedDecoration.SetLocation(origLoc);
			ClientMessage("Cannot drop here.");
		}
	}

}


function UseKeyTargetting()
{
	local vector X, Y, Z, Start;
	local vector XTrig, YTrig, ZTrig, XMov, YMov, ZMov;
	local vector XProj;
	local vector			vecActorDir;
	local vector			vecEye;
	local vector			vecPawnDir;
	local float				fAngle, fAngle2;
	local SFMover			oMoverObj;
	local SFUseKeyTrigger	oTrigObj;
	local SFPickup			oPickUpObj;
	local float				fAngleLimit;
	local float				fTreshold;
	local bool				bHoldingUseWeapon;
	local bool				bHasLineOfSight;
	local bool				bFireEvent;
	local int				UseKeyRange;


	// Some inits
	fAngleLimit			= 0.9f;
	bHoldingUseWeapon	= false;
	UseKeyRange			= SFGameInfo(Level.Game).nUseKeyRange;

	// Get vectors for where the player is aiming on each axis
	GetAxes(ViewRotation, X, Y, Z);

	vecEye	= Location + EyeHeight * vect(0,0,1);
	Start	= Location ;//+ EyeHeight * vect(0,0,1) + vecAiming*0.8*CollisionRadius;

	//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargeting: Start: (" $ Start.x $ "/" $ Start.y $ "/" $ Start.z $")" );

	// Check, if we are currently holding an item
	if(None != CarriedDecoration)
	{
		DropDecoration();
		return;
	}

	// First check for a grab operation
	GrabDecoration();
	if(None != CarriedDecoration)
		return;


	// Check for prybar
	if(None != Weapon)
	{
		if(Weapon.IsA('SFWeapon'))
		{
			bHoldingUseWeapon = true;
		}
	}

	// Trace for UseKeys
/*
	foreach RadiusActors(class'SFUseKeyTrigger', oTrigObj, float(UseKeyRange), Start) //vect(10.0, 10.0, 10.0))
	{
		//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: UseKeyTrace - Actor in range: " $ oTrigObj.name);
		if(None != oTrigObj)
		{
			if(oTrigObj.IsA('SFUseKeyTrigger'))


			{

				fAngle	= getAngle(X, oTrigObj.Location-vecEye);
				if(oTrigObj.IgnoreTouching && (fAngle > fAngleLimit))
				{
					class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found UseKeyTrigger, calling FireEvent");
					oTrigObj.FireEvent(self);

					if((bHoldingUseWeapon) && (oTrigObj.IsA('SFInteractTrigger')))
					{
						if(SFInteractTrigger(oTrigObj).NeededItem == Weapon.class)
							SFWeapon(Weapon).PlayUseKeyHit();
					}

					return; // Do not continue
				}
			}
		}
	}
*/
	// Replacement code from SFHUD (drawUseKeyHint

	bFireEvent	= false;
	foreach RadiusActors(class'SFUseKeyTrigger', oTrigObj, float(UseKeyRange), Start)
	{
		if(None != oTrigObj)
		{
			if(oTrigObj.IsA('SFUseKeyTrigger'))
			{
				if(oTrigObj.IgnoreTouching && !oTrigObj.m_bTriggerNoMore /*&& ( bHasLineOfSight || oTrigObj.bDirectional)*/)
				{
					// LineOfSight check
					if(oTrigObj.bNeedsLineOfSight)
						bHasLineOfSight	= LineOfSightTo(oTrigObj);
					else
						bHasLineOfSight	=	true;

					bFireEvent = bHasLineOfSight;
/*
Removed, because the FOV check is no longer wanted
					vecActorDir	= oTrigObj.Location-Location;
					fAngle		= getAngle(X, oTrigObj.Location-Location);

					fTreshold	= (1.0f- ((UseKeyRange - VSize(vecActorDir)+oTrigObj.CollisionRadius)/UseKeyRange)) *0.7f;

					if(fAngle >= fTreshold)
					{
						// Actor is infront of player, now check if player is in front of actor

						if(!oTrigObj.bDirectional && bHasLineOfSight)
							bFireEvent=true;
						else
						{
							// Check direction of trigger

							// Calc the direction and angle to the trigger
							oTrigObj.GetAxes(oTrigObj.Rotation, XTrig,YTrig,ZTrig);
							vecPawnDir	= Location-oTrigObj.Location;
							fAngle		= getAngle(XTrig, vecPawnDir);

							if(fAngle > 0.8f)
								bFireEvent = true;
						}
					}
*/
					if(bFireEvent)
					{
						class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found UseKeyTrigger, calling FireEvent");
						oTrigObj.FireEvent(self);

						if((bHoldingUseWeapon) && (oTrigObj.IsA('SFInteractTrigger')))
						{
							if(SFInteractTrigger(oTrigObj).NeededItem == Weapon.class)
								SFWeapon(Weapon).PlayUseKeyHit();
						}

						return; // Do not continue
					}
				}
			}
		}
	}


	// Trace for movers
/*
	foreach RadiusActors(class'SFMover', oMoverObj, float(UseKeyRange), Start)
	{
		//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: SFMoverTargetting - Actor in range: " $ oMoverObj.name);
		if(None != oMoverObj)
		{
			if(oMoverObj.IsA('SFMover'))
			{
				fAngle	= getAngle(X, oMoverObj.Location+oMoverObj.CenterOffset-vecEye);
				// class'SFUtils'.static.sfLogEx(5,"fAngle: " $ fAngle $ " Location: " $ oMoverObj.Location $ " RealPosition " $ oMoverObj.RealPosition);
				if(oMoverObj.IgnoreBumping && (fAngle > fAngleLimit))
				{
					//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFMover, calling ManualBump");
					if(oMoverObj.IsInState('TriggerToggle'))
						oMoverObj.ManualTrigger(self);
					else
    					oMoverObj.ManualBump(self);

					return; // Do not continue
				}
			}
		}
	}
*/
	// Replacement code from SFHUD (drawUseKeyHint
	// Trace for movers
	foreach RadiusActors(class'SFMover', oMoverObj, float(UseKeyRange), Start)
	{
		//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: SFMoverTargetting - Actor in range: " $ oMoverObj.name);
		if(None != oMoverObj)
		{
			if(oMoverObj.IsA('SFMover'))
			{
				XProj			= X;
				XProj.Z			= 0.0f;
				vecActorDir		= oMoverObj.Location+oMoverObj.CenterOffset-Location;
				vecActorDir.Z	= 0.0f;

				// class'SFUtils'.static.sfLogEx(5,"fAngle: " $ fAngle $ " Location: " $ oMoverObj.Location $ " RealPosition " $ oMoverObj.RealPosition);
				if(oMoverObj.IgnoreBumping || oMoverObj.IgnoreTrigger)
				{

					bFireEvent	= true;
/*
Removed, because FOV test is no longer wanted.

					fAngle	= getAngle(XProj, vecActorDir);

					// Is infront?
					fTreshold	= (1.0f- ((UseKeyRange - VSize(vecActorDir)+oMoverObj.CollisionRadius)/UseKeyRange)) *0.7f;

					if(fAngle > fTreshold)
					{		
						if(!oMoverObj.bDirectional)
							bFireEvent	= true;
						else
						{
							// Actor is infront of player, now check if player is in front of actor
							// Check direction of trigger

							// Calc the direction and angle to the trigger
							oMoverObj.GetAxes(oMoverObj.Rotation, XMov,YMov,ZMov);
							XProj			= XMov;
							XProj.Z			= 0.0f;
							vecPawnDir		= Location-oMoverObj.Location;
							vecPawnDir.Z	= 0.0f;

							fAngle			= getAngle(XProj, vecPawnDir);
							fTreshold		= (1.0f- ((UseKeyRange - VSize(vecActorDir)+oMoverObj.CollisionRadius)/UseKeyRange)) *0.7f;
							
							if(fAngle > fTreshold)
								bFireEvent=true;
						}
					}
*/
					if(bFireEvent)
					{
						//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFMover, calling ManualBump");
						if(oMoverObj.IsInState('TriggerToggle'))
							oMoverObj.ManualTrigger(self);
						else
    						oMoverObj.ManualBump(self);

						return; // Do not continue
					}
				}
			}
		}
	}

	// Using TraceActors and a 10x10x10 cube for the extents
	foreach RadiusActors(class'SFPickup', oPickUpObj, float(UseKeyRange), Start)
	{
		if(None != oPickUpObj)
		{
			//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: SFPickupTargetting - Actor in range: " $ oPickUpObj.name);
			if(oPickUpObj.IsA('SFPickup'))
			{
				if(oPickUpObj.bManualPickup)
				{
//					fAngle	= getAngle(X, oPickUpObj.Location-vecEye);
//					if(fAngle > fAngleLimit)
//					{
					bHasLineOfSight	= LineOfSightTo(oPickUpObj);
					if(bHasLineOfSight)
					{
						//class'SFUtils'.Static.sfLogEx(4,"SFPlayer - UseKeyTargetting: Found SFPickup, picking it  up.");
						// Mark the pickup as "usekey accessed"
						oPickupObj.bUseKeyHit = true;
						// Pickup the object
						oPickupObj.Touch(self);
						// Reset the "usekey accessed" flag
						oPickupObj.bUseKeyHit = false;
					}

					// Do not continue
					return;
				}
			}
		}
	}

}

// Checks if the room above an actor is unoccupied for a stand up
function bool CheckStandUp(float fDiff)
{






	local bool	bRet;
	local Actor oActor;
	local vector vecHeadPos;
	local vector vecNewPos;
	local vector vecHitNormal;
	local vector vecHitLoc;
	local vector vecExtent;

	// Some inits
	bRet		= true;
	vecExtent.x	= (2.0*CollisionRadius);
	vecExtent.y	= (2.0*CollisionRadius);
	vecExtent.z	= 0.0f;//(2.0*CollisionRadius);

	// Calculate current head pos
	vecHeadPos		= Location;
	vecNewPos		= vecHeadPos;
	vecNewPos.z		+= fDiff +2.0*CollisionRadius;


	// Using TraceActors and a CollisionRadiusXStandCreepDifference cube for the extents
	foreach TraceActors(class'Actor', oActor, vecHitLoc , vecHitNormal , vecNewPos, vecHeadPos, vecExtent)
	{
		// Just mark collision
		bRet=false;
	}

	return bRet;
}

// Checks wheather a movement penalty has to be added or removed for
// the current player state
function bool CheckPenalty(bool bMoveState,  bool bPenaltyAdded, float fPenalty, string strPenaltyName)
{
	local SFWeapon oSFWeapon;

	// Early outs
	if(None == Weapon)
		return false;
	if(!Weapon.IsA('SFWeapon'))
		return false;

	if((bMoveState) && !bPenaltyAdded)
	{
		// Add penalty
		// class'SFUtils'.Static.sflogEx(5, "SFPlayer - CheckPenalty: Adding " $ strPenaltyName $ " penalty");
		bPenaltyAdded=true;
		oSFWeapon = SFWeapon(Weapon);
		if(none != oSFWeapon)
			oSFWeapon.AccuracyPenalty += fPenalty;
		// Log modification for ChangeWeapon event
		oModifiedWeapon		= oSFWeapon;
		fPenaltyModifier	+= fPenalty;
		nPenaltyCount		+= 1;
	}
	if(!bMoveState && bPenaltyAdded)
	{
		// Remove  penalty
		// class'SFUtils'.Static.sflogEx(5, "SFPlayer - CheckPenalty: Removing " $ strPenaltyName $ " penalty");
		oSFWeapon = SFWeapon(Weapon);
		if(none != oSFWeapon)
			oSFWeapon.AccuracyPenalty -= fPenalty;
		// Log modification for ChangeWeapon event
		oModifiedWeapon		= oSFWeapon;
		fPenaltyModifier	-= fPenalty;
		nPenaltyCount		-= 1;
		if( 0 == nPenaltyCount)
		{
			// Reset stat
			oModifiedWeapon.AccuracyPenalty	= 0.0; // Account for FP errors here
			oModifiedWeapon			= none;
			fPenaltyModifier		= 0.0;
		}

		bPenaltyAdded=false;
	}

	return bPenaltyAdded;
}

// Determines, if we are still alive,
// Used from client, to control their action depending on
// their owners state.
function bool isAlive()
{
	if(IsInState('Dying') && bHidden )
		return false;

	return true;
}

function addNewCommunication(SFCommunication oComm)
{
	local SFCommDetail	oNew, oPos;
	local int			i;

	// Check, if this communication has to be added to the history
	if(!oComm.bAddToConversationHistory)
		return;

	oNew = spawn(class'SFCommDetail');

	if(None == m_listCommunications)
	{
		// Add to front
		oNew.m_oNext			= m_listCommunications;
		oNew.m_oNext			= None;
		m_listCommunications	= oNew;
	}
	else
	{
		// Add to end
		oPos	= m_listCommunications;
		// Find end
		while(None != oPos.m_oNext)
			oPos = oPos.m_oNext;
		// Add
		oPos.m_oNext	= oNew;
		oNew.m_oNext	= None;
	}


	// Copy data
	oNew.m_strTitle			= oComm.Title;
	for(i=0; i<25; i++)
		oNew.m_strDetailText[i]	= oComm.DetailText[i];
	// Set dynamic data
	switch(oComm.Type)
	{
		case CT_Captain:
			oNew.m_strType = "Captain";
			break;
		case CT_DataNode:
			oNew.m_strType = "Data Node";
			break;
		case CT_Trainer:
			oNew.m_strType = "Trainer";
			break;
		case CT_NPC:
			oNew.m_strType = "Normal";
			break;
		default:
			oNew.m_strType = "Unknown";
	}
	oNew.m_strReceived = Level.Hour $ ":" $ Level.Minute $ ":" $ Level.Second $ " " $  " " $ Level.Year + 254 $ "/" $ Level.Month $ "/" $ Level.Day;

}

// Called by the communication actor to start a communication
function playCommunication(SFCommunication oComm)
{
	// Early out
	if(None == oComm)
		return;


	// Tell Hud class to playback the communication
	SFHUD(myHUD).playCommunicationDirect(oComm);

}

// Called by the communication actor to start a communication
function addCommunication(SFCommunication oComm)
{

	local SFHUD	oHUD;



	// Early out
	if(None == oComm)
		return;

	// Tell Hud class to playback the communication
	oHUD	= SFHUD(myHUD);
	if(None != oHUD)
		oHUD.queueCommunication(oComm);
	else
		m_oScoutBotComm	= oComm;
}


// Adds/Removes accuracy penalty on the current weapon
function AdjustAccuracy()
{
	// First check jump state
	bJumpPenaltyAdded = CheckPenalty(m_bIsJumping, bJumpPenaltyAdded, JumpAccuracyPenalty*m_fPenaltyUpgrade, "jump");
	// Second check run state
	bRunPenaltyAdded = CheckPenalty((m_bIsRunning && !m_bIsCreeping), bRunPenaltyAdded, RunAccuracyPenalty*m_fPenaltyUpgrade, "run");
	// Thied check strafe state
	bStrafePenaltyAdded = CheckPenalty(m_bIsStrafing, bStrafePenaltyAdded, StrafeAccuracyPenalty*m_fPenaltyUpgrade, "strafe");
}

// Removes all currently added penalties
function resetPenalties()
{
	// First check jump state
	bJumpPenaltyAdded = CheckPenalty(false, bJumpPenaltyAdded, JumpAccuracyPenalty*m_fPenaltyUpgrade, "jump");
	// Second check run state
	bRunPenaltyAdded = CheckPenalty((false && !m_bIsCreeping), bRunPenaltyAdded, RunAccuracyPenalty*m_fPenaltyUpgrade, "run");
	// Thied check strafe state
	bStrafePenaltyAdded = CheckPenalty(false, bStrafePenaltyAdded, StrafeAccuracyPenalty*m_fPenaltyUpgrade, "strafe");

}

// Track change of weapon
function ChangedWeapon()
{
	local Weapon	OldWeapon;
	local Weapon	oNullGun;

	if(	None != m_oCreepPendingWeapon && PlayerState == STATE_Creep)
	{
		PendingWeapon = m_oCreepPendingWeapon;
		m_oCreepPendingWeapon = None;
	}

	// Call to base class
	Super.ChangedWeapon();


	// When changed weapon because of creep mode, remove weapon
	if((PlayerState == STATE_Creep) || m_bDreamMode)
	{
		m_oCreepPendingWeapon = Weapon;
		Weapon = None;
	}

	//class'SFUtils'.Static.sfLogEx(5, "SFPlayer - ChandedWeapon:");

	// Remove penalty on old one
	if(none != oModifiedWeapon)
	{
		// Remove penalty from old one
		oModifiedWeapon.AccuracyPenalty = 0.0;
	}
	if((none != Weapon) && (Weapon.IsA('SFWeapon')))

	{
		// Track new weapon
		oModifiedWeapon		= SFWeapon(Weapon);
		// Add penalty on new one
		oModifiedWeapon.AccuracyPenalty	+= fPenaltyModifier;
		// Keep all penalty counters
	}
	else
	{
		// Reset counters
		fPenaltyModifier	= 0.0;
		nPenaltyCount		= 0;
		oModifiedWeapon		= none;
	}

	// Destroy the NullGun in case we are using a full weapon
	if(!Weapon.IsA('SFNullGun'))
	{
		oNullGun = Weapon(FindInventoryType(class'SFNullGun'));
		if(None != oNullGun)
			oNullGun.Destroy();

	}
}


// Another actor as done a set owner
event GainedChild( Actor Other )
{
	// class'SFUtils'.Static.sfLogEx(6,"SFPlayer - GainedChild: Checking zoneinfo and physic for swimming");

	// Call to base class
	Super.GainedChild(Other);

	// Check for spawn in waterzone
	if ( Region.Zone.bWaterZone && (PlayerRestartState == 'PlayerWalking') )
	{
		// Adjust physics
		setPhysics(PHYS_Swimming);
		GotoState('PlayerSwimming');
	}
}

// Called every time the timer is fired
event Timer()
{
	Super.Timer();
	// Remove Version display
	bShowVersionInfo = false;

}

event Bump( Actor Other )
{
	//class'SFUtils'.Static.sfLogEx(5, "SFPlayer - Bump:  " $ Other.name);
	// Call to base class
	Super.Bump(Other);
}

event HitWall( vector HitNormal, actor HitWall )
{
	//class'SFUtils'.Static.sfLogEx(5, "SFPlayer - HitWall:  " $ HitWall.name $ " (" $ class'SFUtils'.static.FormatFloat(HitNormal.x) $ "/" $ class'SFUtils'.static.FormatFloat(HitNormal.y) $ "/"  $ class'SFUtils'.static.FormatFloat(HitNormal.z) $ ")");
	// Call to base class
	Super.HitWall(HitNormal, HitWall);
}

event BeginPlay()
{
	local int i;

	Super.BeginPlay();

	// log the version
	log("Running Spatial Fear V." $ strSFVersion);

	// Development stuff
	//class'SFUtils'.Static.sfLogEx(5, "SFPlayer - BeginPlay: !!!! : ?? " $ PlayerReplicationInfo.playername);
	if(PlayerReplicationInfo.playername == "McLaud")
	{
		class'SFUtils'.Static.sfLogEx(5, "SFPlayer - BeginPlay: Setting values for " $ PlayerReplicationInfo.playername);
		ConsoleCommand("SFLogLevel 12");
		ConsoleCommand("SFStat all");
	}

	// Show version number
	bShowVersionInfo = false;

}

event Attach(Actor Other)
{
	Super.Attach(Other);
	// class'SFUtils'.Static.sfLogEx(5, "SFPlayer - Attach:");
}

event Spawned()
{
	Super.Spawned();
	// class'SFUtils'.Static.sfLogEx(5, "SFPlayer - Spawned:");
}

event PreBeginPlay()
{
	Super.PreBeginPlay();
	// class'SFUtils'.Static.sfLogEx(5, "SFPlayer - PreBeginPlay:");
}

event PostBeginPlay()
{
	local int i;

	//class'SFUtils'.Static.sfLogEx(5, "SFPlayer - PostBeginPlay:");

	// Call to base class
	Super.PostBeginPlay();

	// set some defaults
	m_bIsJumping	= false;
	m_bIsRunning	= true;
	m_bIsStrafing	= false;
	m_bLoadDialogOpened	=false;
	bJumpPenaltyAdded	= false;
	bRunPenaltyAdded	= false;
	bStrafePenaltyAdded	= false;
	oModifiedWeapon=None;

	// Save original values
    m_fGroundSpeedOrg	= GroundSpeed;
	m_fAirSpeedOrg		= AirSpeed;
	m_fWaterSpeedOrg	= WaterSpeed;
    m_fAccelRate		= AccelRate;
	m_nSafeFallDamage	= SafeFall_Damage;
	m_nSafeFallKill		= SafeFall_Kill;

	// Precalulations
    fDiffStandCrouch	= CollisionHeight-CollisionHeightCrouch;
	fDiffCrouchCreep	= CollisionHeightCrouch-CollisionHeightCreep;
    fDiffStandCreep		= CollisionHeight-CollisionHeightCreep;
	m_fInitialPrePivotZ	= PrePivot.Z;

	// Setup timer to show version info
	SetTimer(nShowVersionTime, false);

	// Adjust player speed
	//class'SFUtils'.Static.sfLogEx(5, "Adjusting player speed to: " $ string(Default.NormalSpeed));
	SFPlayerSpeed(Default.NormalSpeed);

	// Use our own shadow
	if ( Level.NetMode != NM_DedicatedServer )
	{
		Shadow = None; // Release the old reference
		Shadow = Spawn(class'SFPlayerShadow',self);
	}

}


// Check all goaltable bound actors with creation tag
// If they are bound to a not achieved goal they will be destroyed.
function checkActorCreations()
{
	local SFPickup	oPickup;
	local SFHealth	oHealth;
	local SFWeapon	oWeapon;
	local SFTrigger	oTrigger;
	local SFCounter	oCounter;

	// Check pickups

	foreach AllActors( class'SFPickup', oPickup )
	{
		if(oPickup.IsA('SFPickup'))
			// Find all matching pickups for this tag
			if(!m_oGoals.reachedGoal(oPickup.CreateTag))
				// Destroy the pickup
				oPickup.Destroy();
	}
	// Check pickups
	foreach AllActors( class'SFHealth', oHealth )
	{
		if(oHealth.IsA('SFHealth'))
			// Find all matching health for this tag
			if(!m_oGoals.reachedGoal(oHealth.CreateTag))
				// Destroy the pickup
				oHealth.Destroy();
	}
	// Check weapons
	foreach AllActors( class'SFWeapon', oWeapon )
	{
		if(oWeapon.IsA('SFWeapon'))
			// Find all matching weapons for this tag
			if(!m_oGoals.reachedGoal(oWeapon.CreateTag))
				// Destroy the pickup
				oWeapon.Destroy();
	}
	// Check triggers
	foreach AllActors( class'SFTrigger', oTrigger )
	{
		if(oTrigger.IsA('SFTrigger'))
			// Find all matching weapons for this tag
			if(!m_oGoals.reachedGoal(oTrigger.CreateTag))
				// Destroy the pickup
				oTrigger.Destroy();
	}
	// Check counters
	foreach AllActors( class'SFCounter', oCounter )
	{
		if(oCounter.IsA('SFCounter'))
			// Find all matching weapons for this tag
			if(!m_oGoals.reachedGoal(oCounter.CreateTag))
				// Destroy the pickup
				oCounter.Destroy();
	}
}

// FIXME
exec function SFCheckInv()
{
	local Inventory Inv;

	class'SFUtils'.static.sfLogEx(1, "SFPlayer - SFCheckInv: Checking inventory");
	for ( Inv=Inventory; Inv!=None; Inv=Inv.Inventory )
	{
		class'SFUtils'.Static.sfLogEx(1,"SFPlayer - SFCheckInv: Inv: " $ Inv.name );
	}
}

event TravelPostAccept()
{
	local Inventory Inv;

	Super.TravelPostAccept();


	// Do an autosave
	//autoSaveGame();

	checkActorCreations();
/*
	class'SFUtils'.Static.sfLogEx(5,"SFPlayer - TravelPostAccept: Starting ActiveItemBelt population.");
	SFHUD(myHUD).populateActiveItemBelt();
	class'SFUtils'.Static.sfLogEx(5,"SFPlayer - TravelPostAccept: Finished ActiveItemBelt population.");
*/



}



//////////////////////////////
/// States
//////////////////////////////



// Overwrite of PlayerWalking state
state PlayerWalking
{
	exec function FeignDeath()
	{
		// Not supported in SF
	}

	function ServerFeignDeath()
	{
		// Not supported in SF
	}

	// overwrite of AnimEnd function, used to add animation for creeping
	function AnimEnd()
	{
		local name MyAnimGroup;

		bAnimTransition = false;
		if (Physics == PHYS_Walking)
		{
			if(m_bIsCreeping)
			{
				if ( !bIsTurning && ((Velocity.X * Velocity.X + Velocity.Y * Velocity.Y) < 1000) )
				{
					PlayKneel();
				}
				else
				{
					PlayCreeping();
				}

			} else if (bIsCrouching)
			{
				if ( !bIsTurning && ((Velocity.X * Velocity.X + Velocity.Y * Velocity.Y) < 1000) )
				{
					PlayDuck();
				}
				else
				{
					PlayCrawling();
				}
			}
			else
			{
				MyAnimGroup = GetAnimGroup(AnimSequence);
				if ((Velocity.X * Velocity.X + Velocity.Y * Velocity.Y) < 1000)
				{
					if ( MyAnimGroup == 'Waiting' )
					{
						PlayWaiting();
					}
					else
					{
						bAnimTransition = true;
						TweenToWaiting(0.2);
					}
				}
				else if (bIsWalking)
				{
					if ( (MyAnimGroup == 'Waiting') || (MyAnimGroup == 'Landing') || (MyAnimGroup == 'Gesture') || (MyAnimGroup == 'TakeHit')  )
					{
						TweenToWalking(0.1);
						bAnimTransition = true;
					}
					else
						PlayWalking();
				}
				else
				{
					if ( (MyAnimGroup == 'Waiting') || (MyAnimGroup == 'Landing') || (MyAnimGroup == 'Gesture') || (MyAnimGroup == 'TakeHit')  )
					{
						bAnimTransition = true;
						TweenToRunning(0.1);
					}
					else
						PlayRunning();
				}
			}
		}
		else
			PlayInAir();
	}

	// overwrite of Dodge function, used to prevent dodging when

	// in creeping state
	function Dodge(vector" class="source">eDodgeDir DodgeMove)
	{
		// Only do dodging when not creeping
		if(!m_bIsCreeping)
			Super.Dodge(DodgeMove);
		else
			class'SFUtils'.Static.sfLogEx(4,"Dodgeing not possible when creeping");
	}


	// ProcessMove override, used to add creeping movement
	function ProcessMove(float DeltaTime, vector NewAccel, vector" class="source">eDodgeDir DodgeMove, rotator DeltaRot)
	{
		local vector OldAccel;

		OldAccel = Acceleration;
		Acceleration = NewAccel;
		bIsTurning = ( Abs(DeltaRot.Yaw/DeltaTime) > 5000 );
		if ( (DodgeMove == DODGE_Active) && (Physics == PHYS_Falling) )
			DodgeDir = DODGE_Active;
		else if ( (DodgeMove != DODGE_None) && (DodgeMove < DODGE_Active) )
			Dodge(DodgeMove);

		if ( bPressedJump )
			DoJump();
		if ( (Physics == PHYS_Walking) && (GetAnimGroup(AnimSequence) != 'Dodge') )
		{
			// Check for creeping here
			if(!m_bIsCreeping) // Will be set on first encounter
			{
				if (m_bCreep != 0)
				{
					// Mark creeping state
					m_bIsCreeping= true;
					bIsCrouching= false;
					PlayCreeping();
				}
			}
			else
			{
				// Check if still creeping
				if(m_bCreep != 1)
					m_bIsCreeping = false;
			}

			// Check for crouching only, if not creeping
			if ((!bIsCrouching) && (!m_bIsCreeping)) // Will be set on first encounter
			{
				if (bDuck != 0)
				{
					m_bIsCreeping= false;
					bIsCrouching= true;
					PlayDuck();
					//class'SFUtils'.Static.sfLogEx(4,"ProcessMove: bDuck set, bIsCrouching set to true");
				}
			}
			else if ((bDuck == 0) && (m_bCreep== 0))
			{
				OldAccel = vect(0,0,0);
				bIsCrouching= false;
				m_bIsCreeping= false;
				TweenToRunning(0.1);
			}

			if (( !bIsCrouching) && (!m_bIsCreeping))
			{
				if ( (!bAnimTransition || (AnimFrame > 0)) && (GetAnimGroup(AnimSequence) != 'Landing') )
				{
					if ( Acceleration != vect(0,0,0) )
					{
						if ( (GetAnimGroup(AnimSequence) == 'Waiting') || (GetAnimGroup(AnimSequence) == 'Gesture') || (GetAnimGroup(AnimSequence) == 'TakeHit') )
						{
							bAnimTransition = true;
							TweenToRunning(0.1);
						}
					}
			 		else if ( (Velocity.X * Velocity.X + Velocity.Y * Velocity.Y < 1000)
						&& (GetAnimGroup(AnimSequence) != 'Gesture') )
			 		{
			 			if ( GetAnimGroup(AnimSequence) == 'Waiting' )
			 			{

							if ( bIsTurning && (AnimFrame >= 0) )
							{
								bAnimTransition = true;
								PlayTurning();
							}
						}
			 			else if ( !bIsTurning )
						{
							bAnimTransition = true;
							TweenToWaiting(0.2);
						}
					}
				}
			}
			else
			{
				// Crouching / Creeping state
				if(bIsCrouching)
				{
					if ( (OldAccel == vect(0,0,0)) && (Acceleration != vect(0,0,0)) )
						PlayCrawling();
					else if ( !bIsTurning && (Acceleration == vect(0,0,0)) && (AnimFrame > 0.1) )
					{
						PlayDuck();
					}
				}


				if(m_bIsCreeping)
				{
					if ( (OldAccel == vect(0,0,0)) && (Acceleration != vect(0,0,0)) )
					{
						PlayCreeping();
					}
					else if ( !bIsTurning && (Acceleration == vect(0,0,0)) && (AnimFrame > 0.1) )
					{
						PlayKneel();
					}
				}
			}
		}
	}

	event PlayerTick(float DeltaTime)
	{
		local vector X,Y,Z, Dir;

		// Check for autosave here
		if(None != SFHUD(myHUD))
			if(SFHUD(myHud).bFirstTime)
			{
//FIXME: This is crashing in record mode
				autoSaveGame();
				SFHUD(myHud).bFirstTime=false;
			}

		// Call to base class
		Super.PlayerTick(DeltaTime);

		// Call to base class
//		Super.Tick(DeltaTime );

		// Check for jumping state
		m_bIsJumping	= (Physics == PHYS_Falling);
		m_bIsRunning	= !bIsWalking;

		GetAxes(Rotation, X,Y,Z);
		Dir = Normal(Acceleration);
		if ( ( Dir Dot X > -0.75 ) && (Dir Dot X < 0.75) && (Dir != vect(0,0,0)) )
			m_bIsStrafing	= true;
		else
			m_bIsStrafing	= false;

		// Adjust accuracy
		AdjustAccuracy();

		// Eventually reset any modification
		// done to the inputs
		ResetManualInput();

		sweat(DeltaTime);

	}

	// Base class override, to do own initialization
	function BeginState()
	{
		// Call to base class
		Super.BeginState();
		m_bIsCreeping = false;


	}


	// Base class override, to do own cleanup
	function EndState()
	{
		// Call to base class
		Super.EndState();
		m_bIsCreeping = false;

	}

}

// Overwritten here, to prevent the SFRadiationZone from generating
// bubbles, when player is taking damage
function PlayDeathHit(float Damage, vector HitLocation, name damageType, vector Momentum)
{
     local Bubble1 bub;
     local vector Mo;

     if ( Region.Zone.bDestructive && (Region.Zone.ExitActor != None) )
          Spawn(Region.Zone.ExitActor);

     if ((HeadRegion.Zone.bWaterZone) && (!HeadRegion.Zone.IsA('SFRadiationZone')))
     {
          bub = spawn(class 'Bubble1',,, Location
               + 0.3 * CollisionRadius * vector(Rotation) + 0.8 * EyeHeight * vect(0,0,1));
          if (bub != None)
               bub.DrawScale = FRand()*0.08+0.03;
          bub = spawn(class 'Bubble1',,, Location
               + 0.2 * CollisionRadius * VRand() + 0.7 * EyeHeight * vect(0,0,1));
          if (bub != None)
               bub.DrawScale = FRand()*0.08+0.03;
          bub = spawn(class 'Bubble1',,, Location
               + 0.3 * CollisionRadius * VRand() + 0.6 * EyeHeight * vect(0,0,1));
          if (bub != None)
               bub.DrawScale = FRand()*0.08+0.03;
     }

     if ( (!Level.bDropDetail || (FRand() < 0.67))
               && ((DamageType == 'shot') || (DamageType == 'decapitated') || (DamageType == 'shredded')) )
     {
          Mo = Momentum;
          if ( Mo.Z > 0 )
               Mo.Z *= 0.5;
          spawn(class 'UT_BloodHit',self,,hitLocation, rotator(Mo));
     }
     else if ( (damageType != 'Drowned') && (damageType != 'Corroded') )
          spawn(class 'UT_BloodBurst',self,'', hitLocation);
}

// Overwritten here, to prevent the SFRadiationZone from generating
// drowning death sounds.
function PlayDyingSound()
{
     local int rnd;


     if ( HeadRegion.Zone.bWaterZone && !HeadRegion.Zone.IsA('SFRadiationZone'))
     {
          if ( FRand() < 0.5 )
               PlaySound(UWHit1, SLOT_Pain,16,,,Frand()*0.2+0.9);
          else
               PlaySound(UWHit2, SLOT_Pain,16,,,Frand()*0.2+0.9);

          return;
     }

     rnd = Rand(6);
     PlaySound(Deaths[rnd], SLOT_Talk, 16);
     PlaySound(Deaths[rnd], SLOT_Pain, 16);
}

// Overwritten here, to prevent the SFRadiationZone from generating
// drowning death sounds.
function PlayTakeHitSound(int damage, name damageType, int Mult)
{
     if ( Level.TimeSeconds - LastPainSound < 0.3 )
          return;
     LastPainSound = Level.TimeSeconds;

     if ( HeadRegion.Zone.bWaterZone && !HeadRegion.Zone.IsA('SFRadiationZone'))
     {
          if ( damageType == 'Drowned' )
               PlaySound(drown, SLOT_Pain, 12);
          else if ( FRand() < 0.5 )
               PlaySound(UWHit1, SLOT_Pain,16,,,Frand()*0.15+0.9);
          else
               PlaySound(UWHit2, SLOT_Pain,16,,,Frand()*0.15+0.9);
          return;
     }
     damage *= FRand();

     if (damage < 8)
	 {
          PlaySound(HitSound1, SLOT_Pain,16,,,Frand()*0.15+0.9);
  	 }
     else if (damage < 25)
     {
          if (FRand() < 0.5) PlaySound(HitSound2, SLOT_Pain,16,,,Frand()*0.15+0.9);
          else PlaySound(HitSound3, SLOT_Pain,16,,,Frand()*0.15+0.9);
     }
     else
	 {
          PlaySound(HitSound4, SLOT_Pain,16,,,Frand()*0.15+0.9);
	 }
}

function ShowLoadMenu()
{
	WalkBob = vect(0,0,0);
	bShowMenu = true; // menu is responsible for turning this off
	class'SFUtils'.Static.sfLogEx(4,"myHud " $ myHud.name $ " " $ myHud.MainMenu.name);
	Player.Console.GotoState('Menuing');

	class'SFUtils'.Static.sfLogEx(4,"ShowLoadmenu");
	if( Level.Netmode == NM_Standalone )
		SetPause(true);
}

// Base class state override
state FeigningDeath
{
	// Base class override to do initialization
	function BeginState()
	{
		// Call to base class
		Super.BeginState();
		m_bIsCreeping = false;

	}
}


state Climbing
{
ignores SeePlayer, HearNoise, Bump;


	function ZoneChange( ZoneInfo NewZone )
	{
		if (NewZone.bWaterZone)
		{
			setPhysics(PHYS_Swimming);
			GotoState('PlayerSwimming');

		}

	}

	function AnimEnd()
	{

		local name MyAnimGroup;
		local float fVel;

		MyAnimGroup = GetAnimGroup(AnimSequence);
		fVel =  Velocity.X * Velocity.X + Velocity.Z * Velocity.Z;

		if ((fVel) < 0.3)
		{
			if ( MyAnimGroup == 'Waiting' )
				PlayWaiting();
			else
			{
				bAnimTransition = true;
				TweenToWaiting(0.1);
			}
		}
		else
		{
			if ( MyAnimGroup != 'Waiting' )
				PlayWalking();
			else
			{
				bAnimTransition = true;
				TweenToWalking(0.1);
			}
		}
	}

	function ProcessMove(float DeltaTime, vector NewAccel, vector" class="source">eDodgeDir DodgeMove, rotator DeltaRot)
	{
		Acceleration = Normal(NewAccel);
		Velocity = Normal(NewAccel) * 300;
		AutonomousPhysics(DeltaTime);
	}

	event PlayerTick( float DeltaTime )
	{
		if ( bUpdatePosition )
			ClientUpdatePosition();

		PlayerMove(DeltaTime);

		sweat(DeltaTime);
	}

	function PlayerMove(float DeltaTime)
	{
		local float fSpeed2D;
		local rotator newRotation;
		local vector X,Y,Z;

		GetAxes(ViewRotation,X,Y,Z);

		aForward *= 0.1;
		aStrafe  *= 0.1;
		aLookup  *= 0.24;
		aTurn    *= 0.24;
		aUp		 *= 0.1;

		Acceleration = aForward*X + aStrafe*Y + aUp*vect(0,0,1);

		UpdateRotation(DeltaTime, 1);

		fSpeed2D = Sqrt(Velocity.X * Velocity.X + Velocity.Y * Velocity.Y);

		if ( Role < ROLE_Authority ) // then save this move and replicate it
			ReplicateMove(DeltaTime, Acceleration, DODGE_None, rot(0,0,0));
		else
			ProcessMove(DeltaTime, Acceleration, DODGE_None, rot(0,0,0));

		if (fSpeed2D > 10)
			ClimbStepping();
	}

	function BeginState()
	{
		EyeHeight = BaseEyeHeight;

		SetPhysics(PHYS_Flying);
		if  ( !IsAnimating() ) PlayRunning();
	}
}

// ----------------------------------------------------------------------
// state Dying
//

// make sure the death animation finishes
// ----------------------------------------------------------------------

state Dying
{

ignores SeePlayer, HearNoise, KilledBy, Bump, HitWall, HeadZoneChange, FootZoneChange, ZoneChange, SwitchWeapon, Falling, PainTimer;
	event PlayerTick(float deltaTime)
	{
		Super.PlayerTick(deltaTime);
	}

	exec function Fire(optional float F)
	{
//		if ( Level.NetMode != NM_Standalone )
//			Super.Fire();
		if ( Role < ROLE_Authority )
			return;

		if ( Level.NetMode == NM_Standalone )
		{
			//ServerReStartPlayer();
			//loadGame(m_nLastSaveSlot);
			m_bLoadDialogOpened=true;
			SFLoadDialog();
		}

		bJustFired = false;
		bJustAltFired = false;

	}

	exec function ShowMainMenu()
	{
		local UTConsole C;

		class'SFUtils'.Static.sfLogEx(5,"State Dying: ShowMainMenu");

		// reduce the white glow when the menu is up
		if (InstantFog != vect(0,0,0))
		{
			InstantFog   = vect(0.1,0.1,0.1);
			InstantFlash = 0.01;

			// force an update
			ViewFlash(1.0);
		}

//		Global.ShowMainMenu();
//		myHud.bHidden = false;
//		UTConsole(Player.Console).ShowSpeech();
	}

   function TakeDamage(int Damage, Pawn instigatedBy, Vector hitlocation, Vector momentum, name damageType)
	{
	}

	function PlayerCalcView(out actor ViewActor, out vector CameraLocation, out rotator CameraRotation)
	{
		local vector ViewVect, HitLocation, HitNormal;
		local float ViewDist;
		local actor HitActor;
		local float time;

		ViewActor = Self;

		// spiral up and around carcass and fade to white in five seconds
		time = Level.TimeSeconds - m_fFrobTime;

		if (time < 8.0)
		{
			CameraRotation.Pitch = -16384;
			CameraRotation.Yaw = (time * 4096.0) % 65536;
			ViewDist = 32 + time * 16;
			// make sure we don't go through the ceiling
			ViewVect = vect(0,0,1);
			HitActor = Trace(HitLocation, HitNormal, Location + ViewDist * ViewVect, Location);
			if ( HitActor != None )
				CameraLocation = HitLocation;
			else
				CameraLocation = Location + ViewDist * ViewVect;
		}
		else
		{
			CameraRotation.Pitch = -16384;
			CameraRotation.Yaw = (time * 4096.0) % 65536;

			 ViewDist = 32 + 8.0 * 16;

			// make sure we don't go through the ceiling
			ViewVect = vect(0,0,1);
			HitActor = Trace(HitLocation, HitNormal, Location + ViewDist * ViewVect, Location);
			if ( HitActor != None )
				CameraLocation = HitLocation;
			else
				CameraLocation = Location + ViewDist * ViewVect;

			if(!m_bLoadDialogOpened)
			{
				m_bLoadDialogOpened=true;
				SFLoadDialog();
			}
		}

	}

	function BeginState()
	{
		local SFHUD	oHud;

		class'SFUtils'.Static.sfLogEx(5,"SFPlayer - Dying - BeginState: Hiding HUD!");

		// Release decoration
		SlipDecoration();

		// Get the SFHUD
		oHud	= SFHUD(myHud);
		// Save current time
		m_fFrobTime = Level.TimeSeconds;
		// Hide HUD
		oHud.bHideHUD = true;
		// Cancel any active HUD activity
		oHud.CancelComm();

		// Stop any action
		bFrozen = true;
		bPressedJump = false;
		bJustFired = false;
		bJustAltFired = false;

		if(None == Player)
			class'SFUtils'.Static.sfLogEx(5, "SFPlayer - Dying - BeginState: Player already destroyed !!!!");

	}


Begin:

	class'SFUtils'.Static.sfLogEx(5,"SFPlayer - Dying: Entering state");

	// Don't come back to life crouched
	m_bCreep			= 0;
	m_bIsCreeping		= False;
	bDuck				= 0;

	bBehindView = True;
	Velocity = vect(0,0,0);
	Acceleration = vect(0,0,0);
	DesiredFOV = Default.DesiredFOV;
	FinishAnim();

	// hide us and spawn the carcass
	if ( !bHidden )
		SpawnCarcass();
	bHidden = True;

}

state PlayerChat
{
ignores SeePlayer, HearNoise, Bump, TakeDamage, Died, ZoneChange, FootZoneChange;

	event  PlayerInput(float DeltaTime)
	{
		// Do not call the global function that does the additional SF stuff.
		Super.PlayerInput(DeltaTime);
	}

	function UseKeyTargetting()
	{
	}

	exec function Jump( optional float F )
	{
	}

	exec function Suicide()
	{
	}

	exec function Fire(optional float F)
	{
	}

	exec function AltFire(optional float F)
	{
	}

	function ProcessMove(float DeltaTime, vector NewAccel, vector" class="source">eDodgeDir DodgeMove, rotator DeltaRot)
	{
	}

	function PlayWaiting() {}

	event PlayerTick( float DeltaTime )
	{
		if ( bUpdatePosition )
			ClientUpdatePosition();

		PlayerMove(DeltaTime);
	}

	function PlayerMove(float DeltaTime)
	{
	}

	function AnimEnd()
	{
		PlayWaiting();
	}

	function EndState()
	{
//		SetMesh();
		PlayerReplicationInfo.bIsSpectator = false;
		PlayerReplicationInfo.bWaitingPlayer = false;
		SetCollision(true,true,true);
	}

	function BeginState()
	{
//		Mesh = None;
		SetCollision(false,false,false);
		EyeHeight = BaseEyeHeight;
		SetPhysics(PHYS_None);
		PlayWaiting();

	}
}


function bool CanAcceptScoutBotLinkup()
{
	local bool	bRet;

	bRet	= true;
	// MedStation renders on the HUD, so don't loose it...
	if(None != m_actNearestMedStation)
		bRet = false;

	if(!bRet)
		ClientMessage("Currently unable to link up to a ScoutBot!");


	return bRet;

}

state Scouting
{
ignores Fire, AltFire;

	function BeginState()
	{
		local rotator	rot;

		// Set intigator for events
		ScoutBot.Instigator = Self;

		// Clear any reference
		m_oScoutBotComm	= None;

		// Fire entry event
		FireCustomEvent( ScoutBot , Self, 'SFScoutBotEnter');

		//Stand up
		rot	= Rotation;
		rot.pitch	= 0.0f;
		SetRotation(rot);

		PlayWaiting();
	}

	function EndState()
	{
		// Call to base class
		Super.EndState();

		// Fire exit event
		FireCustomEvent( ScoutBot , Self, 'SFScoutBotLeave');

		if(None != m_oScoutBotComm)
			SFHUD(myHUD).queueCommunication(m_oScoutBotComm);
		m_oScoutBotComm = None;
	}

	function AnimEnd()
	{
		PlayWaiting();
	}

	event PlayerTick( float DeltaTime )
	{
		if ( bUpdatePosition )
			ClientUpdatePosition();

		PlayerMove(DeltaTime);
	}

	/**
	Forcing MouseSensitivity to be 1.0 during calculating input stuff.
	*/
	event PlayerInput( float DeltaTime )
	{
		local float	Temp;


		Temp = MouseSensitivity;				// saving MouseSensitivity
		MouseSensitivity = 1.0;					// forcing a value
		super(PlayerPawn).PlayerInput(DeltaTime);		// calculating input stuff
		MouseSensitivity = Temp;				// restoring MouseSensitivity
	}


	function PlayerMove(float DeltaTime)
	{
		if(ScoutBot != None)

			ScoutBot.Drop(vect(0,0,0));	// that's just a damn trick :)) i use Drop function from Decoration class to avoid referencing to SFScoutBot class so i can keep ScoutBot in separate package, but i must say i'm not sure which version of Drop function will be called, the original one from Decoration class or the one from SFScoutBot class
	}

	exec function UseKey()
	{
		ScoutBot.Trigger(Self, Self);
	}
Begin:
	PlayWaiting();
	SlipDecoration();
}



//////////////////////////////
/// Properties
//////////////////////////////

exec function Fire( optional float F )
{
	bJustFired = true;
	if( bShowMenu || (Level.Pauser!="") || (Role < ROLE_Authority) )
	{
		if( (Role < ROLE_Authority) && (Weapon!=None) )
			bJustFired = Weapon.ClientFire(F);
		if ( !bShowMenu && (Level.Pauser == PlayerReplicationInfo.PlayerName)  )
			SetPause(False);
		return;
	}
	if( Weapon!=None )
	{
		Weapon.bPointing = true;
		PlayFiring();
		Weapon.Fire(F);
	}
}

defaultproperties
{
     JumpAccuracyPenalty=1.000000
     RunAccuracyPenalty=1.000000
     StrafeAccuracyPenalty=1.000000
     m_fPenaltyUpgrade=1.000000
     SafeFall_Damage=580.000000
     SafeFall_Kill=940.000000
     CollisionHeightCrouch=28.000000
     CollisionHeightCreep=21.000000
     nShowVersionTime=20
     NormalSpeed=0.800000
     CrouchSpeed=0.300000
     CreepSpeed=0.200000
     ClimbStep=Sound'SpatialFear.Female.FClimb1'
     m_fCurrentSpeedModification=1.000000
     strSFVersion="1.1.182"
     m_bIsRunning=True
     PlayerState=STATE_Normal
     m_fFootstepVolume=2.200000
     m_fLastPheromoneSpawn=-1.000000
     fSoundPitch=1.000000
     GroundSpeed=280.000000
     AirSpeed=280.000000
     AccelRate=1450.000000
     JumpZ=300.000000
     CollisionRadius=14.000000
}